ÿØÿà JFIF    ÿÛ „  ( %"1!%)+...383,7(-.+  -+++--++++---+-+-----+---------------+---+-++7-----ÿÀ  ß â" ÿÄ     ÿÄ H    !1AQaq"‘¡2B±ÁÑð#R“Ò Tbr‚²á3csƒ’ÂñDS¢³$CÿÄ   ÿÄ %  !1AQa"23‘ÿÚ   ? ôÿ ¨pŸªáÿ —åYõõ\?àÒü©ŠÄï¨pŸªáÿ —åYõõ\?àÓü©ŠÄá 0Ÿªáÿ Ÿå[úƒ ú®ði~TÁbqÐ8OÕpÿ ƒOò¤Oè`–RÂáœá™êi€ßÉ< FtŸI“öÌ8úDf´°å}“¾œ6  öFá°y¥jñÇh†ˆ¢ã/ÃÐ:ªcÈ "Y¡ðÑl>ÿ ”ÏËte:qž\oäŠe÷󲍷˜HT4&ÿ ÓÐü6ö®¿øþßèô Ÿ•7Ñi’•j|“ñì>b…þS?*Óôÿ ÓÐü*h¥£ír¶ü UãSç‚Ÿ[AÐaè[ûª•õ&õj?†Éö+EzP—WeÒírJFt ‘BŒ†Ï‡%#tE Øz ¥OÛ«!1›üä±Í™%ºÍãö]°î(–:@<‹ŒÊö×òÆt¦ãº+‡¦%ÌÁ²h´OƒJŒtMÜ>ÀÜÊw3Y´•牋4ǍýʏTì>œú=Íwhyë,¾Ôò×õ¿ßÊa»«þˆѪQ|%6ž™A õ%:øj<>É—ÿ Å_ˆCbõ¥š±ý¯Ýƒï…¶|RëócÍf溪“t.СøTÿ *Ä¿-{†çàczůŽ_–^XþŒ±miB[X±d 1,é”zEù»& î9gœf™9Ð'.;—™i}!ôšåîqêÛ٤ёý£½ÆA–àôe"A$˝Úsäÿ ÷Û #°xŸëí(l »ý3—¥5m! rt`†0~'j2(]S¦¦kv,ÚÇ l¦øJA£Šƒ J3E8ÙiŽ:cÉžúeZ°€¯\®kÖ(79«Ž:¯X”¾³Š&¡* ….‰Ž(ÜíŸ2¥ª‡×Hi²TF¤ò[¨íÈRëÉ䢍mgÑ.Ÿ<öäS0í„ǹÁU´f#Vß;Õ–…P@3ío<ä-±»Ž.L|kªÀê›fÂ6@»eu‚|ÓaÞÆŸ…¨ááå>åŠ?cKü6ùTÍÆ”†sĤÚ;H2RÚ†õ\Ö·Ÿn'¾ ñ#ºI¤Å´%çÁ­‚â7›‹qT3Iï¨ÖÚ5I7Ë!ÅOóŸ¶øÝñØôת¦$Tcö‘[«Ö³šÒ';Aþ ¸èíg A2Z"i¸vdÄ÷.iõ®§)¿]¤À†–‡É&ä{V¶iŽ”.Ó×Õÿ û?h¬Mt–íª[ÿ Ñÿ ÌV(í}=ibÔ¡›¥¢±b Lô¥‡piη_Z<‡z§èŒ)iÖwiÇ 2hÙ3·=’d÷8éŽ1¦¸c¤µ€7›7Ø ð\á)} ¹fËí›pAÃL%âc2 í§æQz¿;T8sæ°qø)QFMð‰XŒÂ±N¢aF¨…8¯!U  Z©RÊ ÖPVÄÀÍin™Ì-GˆªÅËŠ›•zË}º±ŽÍFò¹}Uw×#ä5B¤{î}Ð<ÙD é©¤&‡ïDbàÁôMÁ." ¤‡ú*õ'VŽ|¼´Úgllº¼klz[Æüï÷Aób‡Eÿ dÑ»Xx9ÃÜ£ÁT/`¼¸vI±Ýµ·Ë‚“G³þ*Ÿû´r|*}<¨îºœ @¦mÄ’M¹”.œ«Y–|6ÏU¤jç¥ÕÞqO ˜kDÆÁ¨5ÿ š;Њ¦¦€GÙk \ –Þ=â¼=SͧµªS°ÚÍpÜãQűÀõ¬?ÃÁ1Ñ•õZà?hóœ€ L¦l{Y*K˜Ù›zc˜–ˆâ ø+¾ ­-Ök¥%ùEÜA'}ˆ><ÊIè“bpÍ/qÞâvoX€w,\úªò6Z[XdÒæ­@Ö—€$òJí#é>'°Ú ôª˜<)4ryÙ£|óAÅn5žêŸyÒäMÝ2{"}‰–¤l÷ûWX\l¾Á¸góÉOÔ /óñB¤f¸çñ[.P˜ZsÊË*ßT܈§QN¢’¡¨§V¼(Üù*eÕ“”5T¨‹Âê¥FŒã½Dü[8'Ò¥a…Ú¶k7a *•›¼'Ò·\8¨ª\@\õ¢¦íq+DÙrmÎ…_ªæ»ŠÓœ¡¯’Ré9MÅ×D™lælffc+ŒÑ,ý™ÿ ¯þǤ=Å’Á7µ÷ÚÛ/“Ü€ñýã¼àí¾ÕÑ+ƒ,uµMâÀÄbm:ÒÎPæ{˜Gz[ƒ¯«® KHà`ßØŠéí¯P8Aq.C‰ à€kòpj´kN¶qô€…Õ,ÜNŠª-­{Zö’æû44‰sŽè‰îVíRœÕm" 6?³D9¡ÇTíÅꋇ`4«¸ÝÁô ï’ýorqКÇZ«x4Žâéþuïf¹µö[P ,Q£éaX±`PÉÍZ ¸äYúg üAx ’6Lê‚xÝÓ*äQ  Ï’¨hÍ =²,6ï#rÃ<¯–£»ƒ‹,–ê•€ aÛsñ'%Æ"®ÛüìBᝠHÚ3ß°©$“XnœÖ’î2ËTeûìxîß ¦å¿çÉ ðK§þ{‘t‚Ϋ¬jéîZ[ ”š7L¥4VÚCE×]m¤Øy”ä4-dz£œ§¸x.*ãÊÊ b÷•h:©‡¦s`BTÁRû¾g⻩‹jø sF¢àJøFl‘È•Xᓁà~*j¯ +(ÚÕ6-£¯÷GŠØy‚<Ç’.F‹Hœw(+)ÜÜâÈzÄäT§FߘãÏ;DmVœ3Àu@mÚüXÝü•3B¨òÌÁÛ<·ÃÜ z,Ì@õÅ·d2]ü8s÷IôÞ¯^Ç9¢u„~ëAŸï4«M? K]­ÅàPl@s_ p:°¬ZR”´›JC[CS.h‹ƒïËœ«Æ]–÷ó‚wR×k7X‰k›‘´ù¦=¡«‰¨¨Â')—71ó’c‡Ðúµ `é.{§p¹ój\Ž{1h{o±Ý=áUÊïGÖŒõ–-BÄm+AZX¶¡ ïHðæ¥JmÙ;…ä¡Ÿˆ¦ ° äšiÉg«$üMk5¤L“’çÊvïâï ,=f“"íἊ5ô¬x6{ɏžID0e¸vçmi'︧ºð9$ò¹÷*£’9ÿ ²TÔ…×>JV¥}Œ}$p[bÔ®*[jzS*8 ”·T›Í–ñUîƒwo$áè=LT™ç—~ô·¤ÈÚ$榍q‰„+´kFm)ž‹©i–ËqÞŠ‰à¶ü( ‚•§ •°ò·‡#5ª•µÊ﯅¡X¨šÁ*F#TXJÊ ušJVÍ&=iÄs1‚3•'fý§5Ñ<=[íÞ­ PÚ;ѱÌ_~Ä££8rÞ ²w;’hDT°>ÈG¬8Á²ÚzŽ®ò®qZcqJêäÞ-ö[ܘbň±çb“Š¶31²n×iƒðÕ;1¶þÉ ªX‰,ßqÏ$>•î íZ¥Z 1{ç൵+ƒÕµ¥°T$§K]á»Ûï*·¤tMI’ÂZbŽÕiÒ˜}bÓ0£ª5›¨ [5Ž^ÝœWøÂÝh° ¢OWun£¤5 a2Z.G2³YL]jåtì”ä ÁÓ‘%"©<ÔúÊ°sº UZvä‡ÄiÆÒM .÷V·™ø#kèýiíÌ–ª)µT[)BˆõÑ xB¾B€ÖT¨.¥~ð@VĶr#¸ü*åZNDŽH;âi ],©£öØpù(šºãö¼T.uCê•4@ÿ GÕÛ)Cx›®0ø#:ÏðFÒbR\(€€Ä®fã4Þ‰Fä¯HXƒÅ,†öEÑÔÜ]Öv²?tLÃvBY£ú6Êu5ÅAQ³1‘’¬x–HŒÐ‡ ^ ¸KwJôÖŽ5×CÚ¨vÜ«/B0$×k°=ðbÇ(Ï)w±A†Á† 11Í=èQšµ626ŒÜ/`G«µ<}—-Ö7KEHÈÉðóȤmݱû±·ø«Snmá=“ä«šmݱŸ¡¶~ó·“äUóJæúòB|E LêŽy´jDÔ$G¢þÐñ7óR8ýÒ…Ç› WVe#·Ÿ p·Fx~•ݤF÷0Èÿ K¯æS<6’¡WШ; ´ÿ ¥Êø\Òuî†åÝ–VNœkÒ7oòX¨Á­Ø÷FÎÑä±g÷ÿ M~Çî=p,X´ ÝÌÚÅ‹’ÃjÖ.ØöÏñ qïQ¤ÓZE†° =6·]܈ s¸>v•Ž^Ý\wq9r‰Î\¸¡kURÒ$­*‹Nq?Þª*!sŠÆ:TU_u±T+øX¡ ®¹¡,ÄâÃBTsÜ$Ø›4m椴zÜK]’’›Pƒ @€#â˜`é¹=I‡fiV•Ôî“nRm+µFPOhÍ0B£ €+¬5c v•:P'ÒyÎ ‰V~‚Ó†ÖuókDoh$å\*ö%Ю=£«…aȼ½÷Û.-½VŒŠ¼'lyî±1¬3ó#ÞE¿ÔS¤gV£m›=§\û"—WU¤ÚǼÿ ÂnÁGŒÃ ‚õN D³õNÚíŒÕ;HôyÄÈ©P¹Ä{:?R‘Ô¨âF÷ø£bÅó® JS|‚R÷ivýáâ€Æé¡è³´IئÑT!§˜•Øª‚¬â@q€wnïCWÄ@JU€ê¯m6]Ï:£âx'+ÒðXvÓ¦Úm=–´7œ $ì“B£~p%ÕŸUþ« N@¼üï~w˜ñø5®—'Ôe»¤5ã//€ž~‰Tþ›Å7•#¤× Íö pÄ$ùeåì*«ÓŠEØWEÈsßg ¦ûvžSsLpºÊW–âµEWöˬH; ™!CYõZ ÃÄf æ#1W. \uWâ\,\Çf j’<qTbên›Î[vxx£ë 'ö¨1›˜ÀM¼Pÿ H)ƒêêŒA7s,|F“ 꺸k³9Ìö*ç®;Ö!Ö$Eiž•¹ÒÚ†ýóéÝû¾ÕS®ó$’NÝäŸz¤5r¦ãÄÃD÷Üø!°ø‡Ô&@m™Ì^Ãä­d q5Lnÿ N;.6½·N|#ä"1Nƒx“ã<3('&ñßt  ~ªu”1Tb㫨9ê–›–bìd$ߣ=#ÕãÒmU¯eí$EFù5ýYô櫨æ왍Ǘ±ssM]·á¿0ÕåJRÓªîiƒ+O58ÖñªŠÒx" \µâá¨i’¤i —Ö ” M+M¤ë9‚‰A¦°Qõ¾ßøK~¼Ã‘g…Ö´~÷Ï[3GUœÒ½#…kàÔ®Ò”‰³·dWV‰IP‰Ú8u¹”E ÖqLj¾êÕCBš{A^Âß;–¨`¯¬ìö ˼ ×tìø.tƐm*n¨y4o&Àx¥n¦×î‡aupáÛj8¿m›è¶ã!o½;ß0y^ý×^EÑ¿ÒjzŒ­)vÚÑnÄL …^ªô× ‡—‚3k Îý­hï]içå–îÏ*÷ñþ»Ô CÒjøjÍznˆ´ ¹#b'Fô‹ ‰v¥'’à'T´ƒHýÍ%M‰ ƒ&ÆÇŒï1 ‘ –Þ ‰i¬s žR-Ÿ kŠ¬á¬7:þ 0ŒÅÒÕ/aÙ¬ÃÝ#Úøœ ©aiVc‰. ¹¦ãµ” ›Yg¦›ÆÎýº°f³7ƒhá·¸­}&D9¡ÂsÉÙÞèŠõØàC™¨ñbFC|´Ü(ŸƒÚÒ-%»'a Ì¿)ËÇn¿úÿ ÞŽX…4ÊÅH^ôΑí@ù¹Eh¶“L8Çjù ¼ÎåVªóR©Ï5uà V4lZß®=€xÖŸ–ÑÈ ÷”¨°¾__yM1tÉ?uÆþIkÄgæ@þ[¢†°XÃJ£j·:nkÅ¢u ‘}âGzö­/IµèŠ¬¼48q¦F°ŽR¼=ûì{´¯RýicS ÕÛ íNtÍÙï£,w4rêì®»~x(©Uñ§#Ñ&œÕ¤>ÎåÍÓ9’Ö{9eV­[Öjâ²ãu]˜å2›qÑšÕJç0€sÄ|Êëè0튔bÁ>“{×_F`Ø©ºê:µä,v¤ðfc1±"«ÔÍän1#=· Âøv~H½ÐßA¾¿Ü€Óš]Õ; I¾÷ç‚Qi†î¹9ywÔKG˜áñ zQY—§ÃÕZ07§X‚ Áh;ÁM)iÌCH-¯T‘ë|A0{Ò½LÚ–TâÖkÜ’dÀ“rmm»”جPF³ÖcbE§T€ÒxKºû’Ó®7±²(\4ŽÃ¸Uu@j™yĵ;³µ!Á¢b.W¤=mõ´êµK k ¸K^ÜÛ#p*Ü14qkZç5ïë †°5Ï%ÍÛ<Õ¤×Ô¥ê†C Õ´¼ú$ƒÖ“”]Ù¬qÞÚ[4©ý!ûÏ—Áb쳐XµA¬â~`›Çr¸8ìùÝ䫦<>ä÷«?xs´ÇÑ /á;¹øüÊÈÙà{"@Žïzâ¬[âß‚ U_<ÇŸ½4èN˜ú61®qŠu ¦þF£»äJ_ˆÙÎ~ ÞAã–Ý„Ï—rŠD;xTž‘ô`É«…suãO`?³à™ô Lý#Íc5öoæØ‚y´´÷«ZR§<&JÇ+éâô´€i!Àˆ0æAoàðLèÖ-2ŸõW.’t^–(KÁmHµV@xÜÇy®Ñø­â^:Ú3w· 7½¹°ñ¸â¹®:',«Mœ—n­Á+Ãbš LÈ‘ÄnRÓÅœ%¦²‰¨ùQ:¤f‚ "PÕtô¸…cæl…&˜Ú˜Ôkv‹ž+vŠ,=¢v­6—Xy*¥t£«<™:“aîϲ=¦6rO]XI¿Œ÷¤zÚ­›¶ 6÷”w\d ü~v®ˆÌk«^m<ÿ ¢‰Õ\)ùºŽ;… lîÙÅEŠ®cѾ@vnMÏ,¼“ñ•ŽBxðÃzãÇç%3ˆ"}Ù•Åî> BÉú;Ò]V+P˜F_´ßé> Øše|ï‡ÄOmFæÇ ãqÞ$/xÐx­z`ï9"œÜij‚!7.\Td…9M‡•iŽ‹¾‘50ÞŽn¥ß4ÉôO ¹*í^QêËÜÇÌ8=Ž§s‰'ÂëÙ«á%Pú[O †ÅP¯VsŽ°.‰,kc¶ ¬A9n˜XÎ-ÞšN["¹QÕ‰ƒMýÁߺXJæÍaLj¾×Ãmã¾ãÚ uñÒþåQô¦¥ /ÄUx:‚ÍÜ’ Đ©ØÝ3V¨‰ÕnÐ6ó*óúK­«…c ¯U òhsý­jóÔj#,ímŒRµ«lbïUTŒÑ8†Ä0œÏr`ð¡¬É Ї ë"À² ™ 6¥ f¶ ¢ÚoܱԷ-<Àî)†a¶ž'Ú»¨TXqØæ¶÷YÄHy˜9ÈIW­YÀuMFë ºÏ’AqÌ4·/Ú †ô'i$øä­=Ä Ý|öK×40è|È6p‘0§)o¥ctî§H+CA-“ xØ|ÐXŠç l8íºð3Ø:³¤¬KX¯UÿÙ import * as mozilla from 'source-map'; /** * @param plugins Can also be included with the Processor#use method. * @returns A processor that will apply plugins as CSS processors. */ declare function postcss(plugins?: postcss.AcceptedPlugin[]): postcss.Processor; declare function postcss(...plugins: postcss.AcceptedPlugin[]): postcss.Processor; declare namespace postcss { type AcceptedPlugin = Plugin | Transformer | { postcss: TransformCallback | Processor; } | Processor; /** * Creates a PostCSS plugin with a standard API. * @param name Plugin name. Same as in name property in package.json. It will * be saved in plugin.postcssPlugin property. * @param initializer Will receive plugin options and should return functions * to modify nodes in input CSS. */ function plugin(name: string, initializer: PluginInitializer): Plugin; interface Plugin extends Transformer { (opts?: T): Transformer; postcss: Transformer; process: (css: string | { toString(): string; } | Result, processOpts?: ProcessOptions, pluginOpts?: T) => LazyResult; } interface Transformer extends TransformCallback { postcssPlugin?: string; postcssVersion?: string; } interface TransformCallback { /** * @returns A Promise that resolves when all work is complete. May return * synchronously, but that style of plugin is only meant for debugging and * development. In either case, the resolved or returned value is not used - * the "result" is the output. */ (root: Root, result: Result): Promise | any; } interface PluginInitializer { (pluginOptions?: T): Transformer; } /** * Contains helpers for working with vendor prefixes. */ export namespace vendor { /** * @returns The vendor prefix extracted from the input string. */ function prefix(prop: string): string; /** * @returns The input string stripped of its vendor prefix. */ function unprefixed(prop: string): string; } type ParserInput = string | { toString(): string }; interface Parser { (css: ParserInput, opts?: Pick): Root; } interface Builder { (part: string, node?: Node, type?: 'start' | 'end'): void; } interface Stringifier { (node: Node, builder: Builder): void; } /** * Default function to convert a node tree into a CSS string. */ const stringify: Stringifier; /** * Parses source CSS. * @param css The CSS to parse. * @param options * @returns {} A new Root node, which contains the source CSS nodes. */ const parse: Parser; /** * Contains helpers for safely splitting lists of CSS values, preserving * parentheses and quotes. */ export namespace list { /** * Safely splits space-separated values (such as those for background, * border-radius and other shorthand properties). */ function space(str: string): string[]; /** * Safely splits comma-separated values (such as those for transition-* and * background properties). */ function comma(str: string): string[]; } /** * Creates a new Comment node. * @param defaults Properties for the new Comment node. * @returns The new node. */ function comment(defaults?: CommentNewProps): Comment; /** * Creates a new AtRule node. * @param defaults Properties for the new AtRule node. * @returns The new node. */ function atRule(defaults?: AtRuleNewProps): AtRule; /** * Creates a new Declaration node. * @param defaults Properties for the new Declaration node. * @returns The new node. */ function decl(defaults?: DeclarationNewProps): Declaration; /** * Creates a new Rule node. * @param defaults Properties for the new Rule node. * @returns The new node. */ function rule(defaults?: RuleNewProps): Rule; /** * Creates a new Root node. * @param defaults Properties for the new Root node. * @returns The new node. */ function root(defaults?: object): Root; interface SourceMapOptions { /** * Indicates that the source map should be embedded in the output CSS as a * Base64-encoded comment. By default, it is true. But if all previous maps * are external, not inline, PostCSS will not embed the map even if you do * not set this option. * * If you have an inline source map, the result.map property will be empty, * as the source map will be contained within the text of result.css. */ inline?: boolean; /** * Source map content from a previous processing step (e.g., Sass compilation). * PostCSS will try to read the previous source map automatically (based on comments * within the source CSS), but you can use this option to identify it manually. * If desired, you can omit the previous map with prev: false. */ prev?: any; /** * Indicates that PostCSS should set the origin content (e.g., Sass source) * of the source map. By default, it is true. But if all previous maps do not * contain sources content, PostCSS will also leave it out even if you do not set * this option. */ sourcesContent?: boolean; /** * Indicates that PostCSS should add annotation comments to the CSS. By default, * PostCSS will always add a comment with a path to the source map. PostCSS will * not add annotations to CSS files that do not contain any comments. * * By default, PostCSS presumes that you want to save the source map as * opts.to + '.map' and will use this path in the annotation comment. A different * path can be set by providing a string value for annotation. * * If you have set inline: true, annotation cannot be disabled. */ annotation?: string | boolean; /** * Override "from" in map's sources. */ from?: string; } /** * A Processor instance contains plugins to process CSS. Create one * Processor instance, initialize its plugins, and then use that instance * on numerous CSS files. */ interface Processor { /** * Adds a plugin to be used as a CSS processor. Plugins can also be * added by passing them as arguments when creating a postcss instance. */ use(plugin: AcceptedPlugin): Processor; /** * Parses source CSS. Because some plugins can be asynchronous it doesn't * make any transformations. Transformations will be applied in LazyResult's * methods. * @param css Input CSS or any object with toString() method, like a file * stream. If a Result instance is passed the processor will take the * existing Root parser from it. */ process(css: ParserInput | Result | LazyResult | Root, options?: ProcessOptions): LazyResult; /** * Contains plugins added to this processor. */ plugins: Plugin[]; /** * Contains the current version of PostCSS (e.g., "4.0.5"). */ version: string; } interface ProcessOptions { /** * The path of the CSS source file. You should always set "from", because it is * used in source map generation and syntax error messages. */ from?: string; /** * The path where you'll put the output CSS file. You should always set "to" * to generate correct source maps. */ to?: string; /** * Function to generate AST by string. */ parser?: Parser; /** * Class to generate string by AST. */ stringifier?: Stringifier; /** * Object with parse and stringify. */ syntax?: Syntax; /** * Source map options */ map?: SourceMapOptions | boolean; } interface Syntax { /** * Function to generate AST by string. */ parse?: Parser; /** * Class to generate string by AST. */ stringify?: Stringifier; } /** * A promise proxy for the result of PostCSS transformations. */ interface LazyResult { /** * Processes input CSS through synchronous and asynchronous plugins. * @param onRejected Called if any plugin throws an error. */ then: Promise["then"]; /** * Processes input CSS through synchronous and asynchronous plugins. * @param onRejected Called if any plugin throws an error. */ catch: Promise["catch"]; /** * Alias for css property. */ toString(): string; /** * Processes input CSS through synchronous plugins and converts Root to * CSS string. This property will only work with synchronous plugins. If * the processor contains any asynchronous plugins it will throw an error. * In this case, you should use LazyResult#then() instead. * @returns Result#css. */ css: string; /** * Alias for css property to use when syntaxes generate non-CSS output. */ content: string; /** * Processes input CSS through synchronous plugins. This property will * work only with synchronous plugins. If processor contains any * asynchronous plugins it will throw an error. You should use * LazyResult#then() instead. */ map: ResultMap; /** * Processes input CSS through synchronous plugins. This property will work * only with synchronous plugins. If processor contains any asynchronous * plugins it will throw an error. You should use LazyResult#then() instead. */ root: Root; /** * Processes input CSS through synchronous plugins and calls Result#warnings(). * This property will only work with synchronous plugins. If the processor * contains any asynchronous plugins it will throw an error. In this case, * you should use LazyResult#then() instead. */ warnings(): Warning[]; /** * Processes input CSS through synchronous plugins. This property will work * only with synchronous plugins. If processor contains any asynchronous * plugins it will throw an error. You should use LazyResult#then() instead. */ messages: ResultMessage[]; /** * @returns A processor used for CSS transformations. */ processor: Processor; /** * @returns Options from the Processor#process(css, opts) call that produced * this Result instance. */ opts: ResultOptions; } /** * Provides the result of the PostCSS transformations. */ interface Result { /** * Alias for css property. */ toString(): string; /** * Creates an instance of Warning and adds it to messages. * @param message Used in the text property of the message object. * @param options Properties for Message object. */ warn(message: string, options?: WarningOptions): void; /** * @returns Warnings from plugins, filtered from messages. */ warnings(): Warning[]; /** * A CSS string representing this Result's Root instance. */ css: string; /** * Alias for css property to use with syntaxes that generate non-CSS output. */ content: string; /** * An instance of the SourceMapGenerator class from the source-map library, * representing changes to the Result's Root instance. * This property will have a value only if the user does not want an inline * source map. By default, PostCSS generates inline source maps, written * directly into the processed CSS. The map property will be empty by default. * An external source map will be generated — and assigned to map — only if * the user has set the map.inline option to false, or if PostCSS was passed * an external input source map. */ map: ResultMap; /** * Contains the Root node after all transformations. */ root?: Root; /** * Contains messages from plugins (e.g., warnings or custom messages). * Add a warning using Result#warn() and get all warnings * using the Result#warnings() method. */ messages: ResultMessage[]; /** * The Processor instance used for this transformation. */ processor?: Processor; /** * Options from the Processor#process(css, opts) or Root#toResult(opts) call * that produced this Result instance. */ opts?: ResultOptions; } interface ResultOptions extends ProcessOptions { /** * The CSS node that was the source of the warning. */ node?: postcss.Node; /** * Name of plugin that created this warning. Result#warn() will fill it * automatically with plugin.postcssPlugin value. */ plugin?: string; } interface ResultMap { /** * Add a single mapping from original source line and column to the generated * source's line and column for this source map being created. The mapping * object should have the following properties: * @param mapping * @returns {} */ addMapping(mapping: mozilla.Mapping): void; /** * Set the source content for an original source file. * @param sourceFile The URL of the original source file. * @param sourceContent The content of the source file. */ setSourceContent(sourceFile: string, sourceContent: string): void; /** * Applies a SourceMap for a source file to the SourceMap. Each mapping to * the supplied source file is rewritten using the supplied SourceMap. * Note: The resolution for the resulting mappings is the minimum of this * map and the supplied map. * @param sourceMapConsumer The SourceMap to be applied. * @param sourceFile The filename of the source file. If omitted, sourceMapConsumer * file will be used, if it exists. Otherwise an error will be thrown. * @param sourceMapPath The dirname of the path to the SourceMap to be applied. * If relative, it is relative to the SourceMap. This parameter is needed when * the two SourceMaps aren't in the same directory, and the SourceMap to be * applied contains relative source paths. If so, those relative source paths * need to be rewritten relative to the SourceMap. * If omitted, it is assumed that both SourceMaps are in the same directory; * thus, not needing any rewriting (Supplying '.' has the same effect). */ applySourceMap( sourceMapConsumer: mozilla.SourceMapConsumer, sourceFile?: string, sourceMapPath?: string ): void; /** * Renders the source map being generated to JSON. */ toJSON: () => mozilla.RawSourceMap; /** * Renders the source map being generated to a string. */ toString: () => string; } interface ResultMessage { type: string; plugin: string; [others: string]: any; } /** * Represents a plugin warning. It can be created using Result#warn(). */ interface Warning { /** * @returns Error position, message. */ toString(): string; /** * Contains the warning message. */ text: string; /** * Contains the name of the plugin that created this warning. When you * call Result#warn(), it will fill this property automatically. */ plugin: string; /** * The CSS node that caused the warning. */ node: Node; /** * The line in the input file with this warning's source. */ line: number; /** * Column in the input file with this warning's source. */ column: number; } interface WarningOptions extends ResultOptions { /** * A word inside a node's string that should be highlighted as source * of warning. */ word?: string; /** * The index inside a node's string that should be highlighted as * source of warning. */ index?: number; } /** * The CSS parser throws this error for broken CSS. */ interface CssSyntaxError extends InputOrigin { name: string; /** * @returns Error position, message and source code of broken part. */ toString(): string; /** * @param color Whether arrow should be colored red by terminal color codes. * By default, PostCSS will use process.stdout.isTTY and * process.env.NODE_DISABLE_COLORS. * @returns A few lines of CSS source that caused the error. If CSS has * input source map without sourceContent this method will return an empty * string. */ showSourceCode(color?: boolean): string; /** * Contains full error text in the GNU error format. */ message: string; /** * Contains only the error description. */ reason: string; /** * Contains the PostCSS plugin name if the error didn't come from the * CSS parser. */ plugin?: string; input?: InputOrigin; } interface InputOrigin { /** * If parser's from option is set, contains the absolute path to the * broken file. PostCSS will use the input source map to detect the * original error location. If you wrote a Sass file, then compiled it * to CSS and parsed it with PostCSS, PostCSS will show the original * position in the Sass file. If you need the position in the PostCSS * input (e.g., to debug the previous compiler), use error.input.file. */ file?: string; /** * Contains the source line of the error. PostCSS will use the input * source map to detect the original error location. If you wrote a Sass * file, then compiled it to CSS and parsed it with PostCSS, PostCSS * will show the original position in the Sass file. If you need the * position in the PostCSS input (e.g., to debug the previous * compiler), use error.input.line. */ line?: number; /** * Contains the source column of the error. PostCSS will use input * source map to detect the original error location. If you wrote a * Sass file, then compiled it to CSS and parsed it with PostCSS, * PostCSS will show the original position in the Sass file. If you * need the position in the PostCSS input (e.g., to debug the * previous compiler), use error.input.column. */ column?: number; /** * Contains the source code of the broken file. PostCSS will use the * input source map to detect the original error location. If you wrote * a Sass file, then compiled it to CSS and parsed it with PostCSS, * PostCSS will show the original position in the Sass file. If you need * the position in the PostCSS input (e.g., to debug the previous * compiler), use error.input.source. */ source?: string; } export class PreviousMap { private inline; annotation: string; root: string; private consumerCache; text: string; file: string; constructor(css: any, opts: any); consumer(): mozilla.SourceMapConsumer; withContent(): boolean; startWith(string: string, start: string): boolean; loadAnnotation(css: string): void; decodeInline(text: string): string; loadMap( file: any, prev: string | Function | mozilla.SourceMapConsumer | mozilla.SourceMapGenerator | mozilla.RawSourceMap ): string; isMap(map: any): boolean; } /** * Represents the source CSS. */ interface Input { /** * The absolute path to the CSS source file defined with the "from" option. * Either this property or the "id" property are always defined. */ file?: string; /** * The unique ID of the CSS source. Used if "from" option is not provided * (because PostCSS does not know the file path). Either this property * or the "file" property are always defined. */ id?: string; /** * The CSS source identifier. Contains input.file if the user set the * "from" option, or input.id if they did not. */ from: string; /** * Represents the input source map passed from a compilation step before * PostCSS (e.g., from the Sass compiler). */ map: PreviousMap; /** * The flag to indicate whether or not the source code has Unicode BOM. */ hasBOM: boolean; /** * Reads the input source map. * @returns A symbol position in the input source (e.g., in a Sass file * that was compiled to CSS before being passed to PostCSS): */ origin(line: number, column: number): InputOrigin | false; } type ChildNode = AtRule | Rule | Declaration | Comment; type Node = Root | ChildNode; interface NodeBase { /** * Returns the input source of the node. The property is used in source * map generation. If you create a node manually * (e.g., with postcss.decl() ), that node will not have a source * property and will be absent from the source map. For this reason, the * plugin developer should consider cloning nodes to create new ones * (in which case the new node's source will reference the original, * cloned node) or setting the source property manually. */ source?: NodeSource; /** * Contains information to generate byte-to-byte equal node string as it * was in origin input. */ raws: NodeRaws; /** * @returns A CSS string representing the node. */ toString(stringifier?: Stringifier | Syntax): string; /** * This method produces very useful error messages. If present, an input * source map will be used to get the original position of the source, even * from a previous compilation step (e.g., from Sass compilation). * @returns The original position of the node in the source, showing line * and column numbers and also a small excerpt to facilitate debugging. */ error( /** * Error description. */ message: string, options?: NodeErrorOptions): CssSyntaxError; /** * Creates an instance of Warning and adds it to messages. This method is * provided as a convenience wrapper for Result#warn. * Note that `opts.node` is automatically passed to Result#warn for you. * @param result The result that will receive the warning. * @param text Warning message. It will be used in the `text` property of * the message object. * @param opts Properties to assign to the message object. */ warn(result: Result, text: string, opts?: WarningOptions): void; /** * @returns The next child of the node's parent; or, returns undefined if * the current node is the last child. */ next(): ChildNode | void; /** * @returns The previous child of the node's parent; or, returns undefined * if the current node is the first child. */ prev(): ChildNode | void; /** * Insert new node before current node to current node’s parent. * * Just an alias for `node.parent.insertBefore(node, newNode)`. * * @returns this node for method chaining. * * @example * decl.before('content: ""'); */ before(newNode: Node | object | string | Node[]): this; /** * Insert new node after current node to current node’s parent. * * Just an alias for `node.parent.insertAfter(node, newNode)`. * * @returns this node for method chaining. * * @example * decl.after('color: black'); */ after(newNode: Node | object | string | Node[]): this; /** * @returns The Root instance of the node's tree. */ root(): Root; /** * Removes the node from its parent and cleans the parent property in the * node and its children. * @returns This node for chaining. */ remove(): this; /** * Inserts node(s) before the current node and removes the current node. * @returns This node for chaining. */ replaceWith(...nodes: (Node | object)[]): this; /** * @param overrides New properties to override in the clone. * @returns A clone of this node. The node and its (cloned) children will * have a clean parent and code style properties. */ clone(overrides?: object): this; /** * Shortcut to clone the node and insert the resulting cloned node before * the current node. * @param overrides New Properties to override in the clone. * @returns The cloned node. */ cloneBefore(overrides?: object): this; /** * Shortcut to clone the node and insert the resulting cloned node after * the current node. * @param overrides New Properties to override in the clone. * @returns The cloned node. */ cloneAfter(overrides?: object): this; /** * @param prop Name or code style property. * @param defaultType Name of default value. It can be easily missed if the * value is the same as prop. * @returns A code style property value. If the node is missing the code * style property (because the node was manually built or cloned), PostCSS * will try to autodetect the code style property by looking at other nodes * in the tree. */ raw(prop: string, defaultType?: string): any; } interface NodeNewProps { source?: NodeSource; raws?: NodeRaws; } interface NodeRaws { /** * The space symbols before the node. It also stores `*` and `_` * symbols before the declaration (IE hack). */ before?: string; /** * The space symbols after the last child of the node to the end of * the node. */ after?: string; /** * The symbols between the property and value for declarations, * selector and "{" for rules, last parameter and "{" for at-rules. */ between?: string; /** * True if last child has (optional) semicolon. */ semicolon?: boolean; /** * The space between the at-rule's name and parameters. */ afterName?: string; /** * The space symbols between "/*" and comment's text. */ left?: string; /** * The space symbols between comment's text and "*\/". */ right?: string; /** * The content of important statement, if it is not just "!important". */ important?: string; } interface NodeSource { input: Input; /** * The starting position of the node's source. */ start?: { column: number; line: number; }; /** * The ending position of the node's source. */ end?: { column: number; line: number; }; } interface NodeErrorOptions { /** * Plugin name that created this error. PostCSS will set it automatically. */ plugin?: string; /** * A word inside a node's string, that should be highlighted as source * of error. */ word?: string; /** * An index inside a node's string that should be highlighted as source * of error. */ index?: number; } interface JsonNode { /** * Returns a string representing the node's type. Possible values are * root, atrule, rule, decl or comment. */ type?: string; /** * Returns the node's parent node. */ parent?: JsonContainer; /** * Returns the input source of the node. The property is used in source * map generation. If you create a node manually (e.g., with * postcss.decl() ), that node will not have a source property and * will be absent from the source map. For this reason, the plugin * developer should consider cloning nodes to create new ones (in which * case the new node's source will reference the original, cloned node) * or setting the source property manually. */ source?: NodeSource; /** * Contains information to generate byte-to-byte equal node string as it * was in origin input. */ raws?: NodeRaws; } type Container = Root | AtRule | Rule; /** * Containers can store any content. If you write a rule inside a rule, * PostCSS will parse it. */ interface ContainerBase extends NodeBase { /** * Contains the container's children. */ nodes?: ChildNode[]; /** * @returns The container's first child. */ first?: ChildNode; /** * @returns The container's last child. */ last?: ChildNode; /** * @param overrides New properties to override in the clone. * @returns A clone of this node. The node and its (cloned) children will * have a clean parent and code style properties. */ clone(overrides?: object): this; /** * @param child Child of the current container. * @returns The child's index within the container's "nodes" array. */ index(child: ChildNode | number): number; /** * Determines whether all child nodes satisfy the specified test. * @param callback A function that accepts up to three arguments. The * every method calls the callback function for each node until the * callback returns false, or until the end of the array. * @returns True if the callback returns true for all of the container's * children. */ every(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => any, thisArg?: any): boolean; /** * Determines whether the specified callback returns true for any child node. * @param callback A function that accepts up to three arguments. The some * method calls the callback for each node until the callback returns true, * or until the end of the array. * @param thisArg An object to which the this keyword can refer in the * callback function. If thisArg is omitted, undefined is used as the * this value. * @returns True if callback returns true for (at least) one of the * container's children. */ some(callback: (node: ChildNode, index: number, nodes: ChildNode[]) => boolean, thisArg?: any): boolean; /** * Iterates through the container's immediate children, calling the * callback function for each child. If you need to recursively iterate * through all the container's descendant nodes, use container.walk(). * Unlike the for {} -cycle or Array#forEach() this iterator is safe if * you are mutating the array of child nodes during iteration. * @param callback Iterator. Returning false will break iteration. Safe * if you are mutating the array of child nodes during iteration. PostCSS * will adjust the current index to match the mutations. * @returns False if the callback returns false during iteration. */ each(callback: (node: ChildNode, index: number) => any): boolean | void; /** * Traverses the container's descendant nodes, calling `callback` for each * node. Like container.each(), this method is safe to use if you are * mutating arrays during iteration. If you only need to iterate through * the container's immediate children, use container.each(). * @param callback Iterator. */ walk(callback: (node: ChildNode, index: number) => any): boolean | void; /** * Traverses the container's descendant nodes, calling `callback` for each * declaration. Like container.each(), this method is safe to use if you * are mutating arrays during iteration. * @param propFilter Filters declarations by property name. Only those * declarations whose property matches propFilter will be iterated over. * @param callback Called for each declaration node within the container. */ walkDecls(propFilter: string | RegExp, callback?: (decl: Declaration, index: number) => any): boolean | void; walkDecls(callback: (decl: Declaration, index: number) => any): boolean | void; /** * Traverses the container's descendant nodes, calling `callback` for each * at-rule. Like container.each(), this method is safe to use if you are * mutating arrays during iteration. * @param nameFilter Filters at-rules by name. If provided, iteration * will only happen over at-rules that have matching names. * @param callback Iterator called for each at-rule node within the * container. */ walkAtRules(nameFilter: string | RegExp, callback: (atRule: AtRule, index: number) => any): boolean | void; walkAtRules(callback: (atRule: AtRule, index: number) => any): boolean | void; /** * Traverses the container's descendant nodes, calling `callback` for each * rule. Like container.each(), this method is safe to use if you are * mutating arrays during iteration. * @param selectorFilter Filters rules by selector. If provided, * iteration will only happen over rules that have matching names. * @param callback Iterator called for each rule node within the * container. */ walkRules(selectorFilter: string | RegExp, callback: (atRule: Rule, index: number) => any): boolean | void; walkRules(callback: (atRule: Rule, index: number) => any): boolean | void; walkRules(selectorFilter: any, callback?: (atRule: Rule, index: number) => any): boolean | void; /** * Traverses the container's descendant nodes, calling `callback` for each * comment. Like container.each(), this method is safe to use if you are * mutating arrays during iteration. * @param callback Iterator called for each comment node within the container. */ walkComments(callback: (comment: Comment, indexed: number) => any): void | boolean; /** * Passes all declaration values within the container that match pattern * through the callback, replacing those values with the returned result of * callback. This method is useful if you are using a custom unit or * function and need to iterate through all values. * @param pattern Pattern that we need to replace. * @param options Options to speed up the search. * @param callbackOrReplaceValue String to replace pattern or callback * that will return a new value. The callback will receive the same * arguments as those passed to a function parameter of String#replace. */ replaceValues(pattern: string | RegExp, options: { /** * Property names. The method will only search for values that match * regexp within declarations of listed properties. */ props?: string[]; /** * Used to narrow down values and speed up the regexp search. Searching * every single value with a regexp can be slow. If you pass a fast * string, PostCSS will first check whether the value contains the fast * string; and only if it does will PostCSS check that value against * regexp. For example, instead of just checking for /\d+rem/ on all * values, set fast: 'rem' to first check whether a value has the rem * unit, and only if it does perform the regexp check. */ fast?: string; }, callbackOrReplaceValue: string | { (substring: string, ...args: any[]): string; }): this; replaceValues(pattern: string | RegExp, callbackOrReplaceValue: string | { (substring: string, ...args: any[]): string; }): this; /** * Inserts new nodes to the beginning of the container. * Because each node class is identifiable by unique properties, use the * following shortcuts to create nodes in insert methods: * root.prepend({ name: '@charset', params: '"UTF-8"' }); // at-rule * root.prepend({ selector: 'a' }); // rule * rule.prepend({ prop: 'color', value: 'black' }); // declaration * rule.prepend({ text: 'Comment' }) // comment * A string containing the CSS of the new element can also be used. This * approach is slower than the above shortcuts. * root.prepend('a {}'); * root.first.prepend('color: black; z-index: 1'); * @param nodes New nodes. * @returns This container for chaining. */ prepend(...nodes: (Node | object | string)[]): this; /** * Inserts new nodes to the end of the container. * Because each node class is identifiable by unique properties, use the * following shortcuts to create nodes in insert methods: * root.append({ name: '@charset', params: '"UTF-8"' }); // at-rule * root.append({ selector: 'a' }); // rule * rule.append({ prop: 'color', value: 'black' }); // declaration * rule.append({ text: 'Comment' }) // comment * A string containing the CSS of the new element can also be used. This * approach is slower than the above shortcuts. * root.append('a {}'); * root.first.append('color: black; z-index: 1'); * @param nodes New nodes. * @returns This container for chaining. */ append(...nodes: (Node | object | string)[]): this; /** * Insert newNode before oldNode within the container. * @param oldNode Child or child's index. * @returns This container for chaining. */ insertBefore(oldNode: ChildNode | number, newNode: ChildNode | object | string): this; /** * Insert newNode after oldNode within the container. * @param oldNode Child or child's index. * @returns This container for chaining. */ insertAfter(oldNode: ChildNode | number, newNode: ChildNode | object | string): this; /** * Removes the container from its parent and cleans the parent property in the * container and its children. * @returns This container for chaining. */ remove(): this; /** * Removes child from the container and cleans the parent properties * from the node and its children. * @param child Child or child's index. * @returns This container for chaining. */ removeChild(child: ChildNode | number): this; /** * Removes all children from the container and cleans their parent * properties. * @returns This container for chaining. */ removeAll(): this; } interface ContainerNewProps extends NodeNewProps { /** * Contains the container's children. */ nodes?: ChildNode[]; raws?: ContainerRaws; } interface ContainerRaws extends NodeRaws { indent?: string; } interface JsonContainer extends JsonNode { /** * Contains the container's children. */ nodes?: ChildNode[]; /** * @returns The container's first child. */ first?: ChildNode; /** * @returns The container's last child. */ last?: ChildNode; } /** * Represents a CSS file and contains all its parsed nodes. */ interface Root extends ContainerBase { type: 'root'; /** * Inherited from Container. Should always be undefined for a Root node. */ parent: void; /** * @param overrides New properties to override in the clone. * @returns A clone of this node. The node and its (cloned) children will * have a clean parent and code style properties. */ clone(overrides?: object): this; /** * @returns A Result instance representing the root's CSS. */ toResult(options?: { /** * The path where you'll put the output CSS file. You should always * set "to" to generate correct source maps. */ to?: string; map?: SourceMapOptions; }): Result; /** * Removes child from the root node, and the parent properties of node and * its children. * @param child Child or child's index. * @returns This root node for chaining. */ removeChild(child: ChildNode | number): this; } interface RootNewProps extends ContainerNewProps { } interface JsonRoot extends JsonContainer { } /** * Represents an at-rule. If it's followed in the CSS by a {} block, this * node will have a nodes property representing its children. */ interface AtRule extends ContainerBase { type: 'atrule'; /** * Returns the atrule's parent node. */ parent: Container; /** * The identifier that immediately follows the @. */ name: string; /** * These are the values that follow the at-rule's name, but precede any {} * block. The spec refers to this area as the at-rule's "prelude". */ params: string; /** * @param overrides New properties to override in the clone. * @returns A clone of this node. The node and its (cloned) children will * have a clean parent and code style properties. */ clone(overrides?: object): this; } interface AtRuleNewProps extends ContainerNewProps { /** * The identifier that immediately follows the @. */ name?: string; /** * These are the values that follow the at-rule's name, but precede any {} * block. The spec refers to this area as the at-rule's "prelude". */ params?: string | number; raws?: AtRuleRaws; } interface AtRuleRaws extends NodeRaws { params?: string; } interface JsonAtRule extends JsonContainer { /** * The identifier that immediately follows the @. */ name?: string; /** * These are the values that follow the at-rule's name, but precede any {} * block. The spec refers to this area as the at-rule's "prelude". */ params?: string; } /** * Represents a CSS rule: a selector followed by a declaration block. */ interface Rule extends ContainerBase { type: 'rule'; /** * Returns the rule's parent node. */ parent: Container; /** * The rule's full selector. If there are multiple comma-separated selectors, * the entire group will be included. */ selector: string; /** * An array containing the rule's individual selectors. * Groups of selectors are split at commas. */ selectors: string[]; /** * @param overrides New properties to override in the clone. * @returns A clone of this node. The node and its (cloned) children will * have a clean parent and code style properties. */ clone(overrides?: object): this; } interface RuleNewProps extends ContainerNewProps { /** * The rule's full selector. If there are multiple comma-separated selectors, * the entire group will be included. */ selector?: string; /** * An array containing the rule's individual selectors. Groups of selectors * are split at commas. */ selectors?: string[]; raws?: RuleRaws; } interface RuleRaws extends ContainerRaws { /** * The rule's full selector. If there are multiple comma-separated selectors, * the entire group will be included. */ selector?: string; } interface JsonRule extends JsonContainer { /** * The rule's full selector. If there are multiple comma-separated selectors, * the entire group will be included. */ selector?: string; /** * An array containing the rule's individual selectors. * Groups of selectors are split at commas. */ selectors?: string[]; } /** * Represents a CSS declaration. */ interface Declaration extends NodeBase { type: 'decl'; /** * Returns the declaration's parent node. */ parent: Container; /** * The declaration's property name. */ prop: string; /** * The declaration's value. This value will be cleaned of comments. If the * source value contained comments, those comments will be available in the * _value.raws property. If you have not changed the value, the result of * decl.toString() will include the original raws value (comments and all). */ value: string; /** * True if the declaration has an !important annotation. */ important: boolean; /** * @param overrides New properties to override in the clone. * @returns A clone of this node. The node and its (cloned) children will * have a clean parent and code style properties. */ clone(overrides?: object): this; } interface DeclarationNewProps { /** * The declaration's property name. */ prop?: string; /** * The declaration's value. This value will be cleaned of comments. If the * source value contained comments, those comments will be available in the * _value.raws property. If you have not changed the value, the result of * decl.toString() will include the original raws value (comments and all). */ value?: string; raws?: DeclarationRaws; } interface DeclarationRaws extends NodeRaws { /** * The declaration's value. This value will be cleaned of comments. * If the source value contained comments, those comments will be * available in the _value.raws property. If you have not changed the value, the result of * decl.toString() will include the original raws value (comments and all). */ value?: string; } interface JsonDeclaration extends JsonNode { /** * True if the declaration has an !important annotation. */ important?: boolean; } /** * Represents a comment between declarations or statements (rule and at-rules). * Comments inside selectors, at-rule parameters, or declaration values will * be stored in the Node#raws properties. */ interface Comment extends NodeBase { type: 'comment'; /** * Returns the comment's parent node. */ parent: Container; /** * The comment's text. */ text: string; /** * @param overrides New properties to override in the clone. * @returns A clone of this node. The node and its (cloned) children will * have a clean parent and code style properties. */ clone(overrides?: object): this; } interface CommentNewProps { /** * The comment's text. */ text?: string; } interface JsonComment extends JsonNode { } } export = postcss;