normalitalicindexvaluew100w200w300w400w500w600w700w800w900boldvalueslerptoStringfeature _kEncodedSize_encode==hashCodeaxisgraphemeClusterLayoutBoundsgraphemeClusterCodeUnitRangewritingDirectionleftrightcenterjustifystartend alphabetic ideographic_maskcontainsnone underlineoverline lineThroughsoliddoubledotteddashedwavy proportionalevenapplyHeightToFirstAscentapplyHeightToLastDescentleadingDistribution_encoded _fontFamily_fontFamilyFallback _fontSize_letterSpacing _wordSpacing_height_decorationThickness_locale _background _foreground_shadows _fontFeatures_fontVariations_leadingDistribution _strutStyle _ellipsis_enabledrtlltrtopbottom directiontoRectupstream downstreamoffsetaffinityemptyisValid isCollapsed isNormalized textBefore textAfter textInsidewidthtightmaxincludeLineSpacingMiddleincludeLineSpacingTopincludeLineSpacingBottomstrutbaseline aboveBaseline belowBaselinemiddle hardBreakascentdescentunscaledAscentheight lineNumber longestLineminIntrinsicWidthmaxIntrinsicWidthalphabeticBaselineideographicBaselinedidExceedMaxLineslayoutgetBoxesForRangegetBoxesForPlaceholdersgetPositionForOffsetgetClosestGlyphInfoForOffsetgetGlyphInfoAtgetWordBoundarygetLineBoundarycomputeLineMetricsgetLineMetricsAt numberOfLinesgetLineNumberAtdispose debugDisposed _needsLayout_layout_decodeTextBoxes_getBoxesForRange_getBoxesForPlaceholders_getPositionForOffset_getGlyphInfoAt_getClosestGlyphInfoForOffset_getWordBoundary_getLineBoundary_paint_computeLineMetrics_getLineMetricsAt_getLineNumber_dispose _disposedplaceholderCountplaceholderScales pushStylepopaddTextaddPlaceholderbuild _constructor_placeholderCount_placeholderScales_defaultLeadingDistribution _pushStyle _encodeLocale_addText_addPlaceholder_build%kTextHeightNone FontStyle FontWeight FontFeature FontVariation GlyphInfo TextAlign TextBaselineTextDecorationTextDecorationStyleTextLeadingDistributionTextHeightBehavior _listEquals_encodeTextStyle TextStyle_encodeParagraphStyleParagraphStyle _encodeStrut StrutStyle TextDirectionTextBox TextAffinity TextPosition TextRangeParagraphConstraintsBoxHeightStyle BoxWidthStylePlaceholderAlignment LineMetrics Paragraph_NativeParagraphParagraphBuilder_NativeParagraphBuilderloadFontFromList_fontChangeMessage_sendFontChangeMessage_loadFontFromListdartuiheightfontSizedoubleitalicslantnormalboldw500weightint_ListCurves elasticInOutAnimationController_lerpIntindexroundclampoverrideStringlengthwidgetsTextrich fractions randomize stylisticSettoStringpadLeft numerators denominatoralternativeFractionshistoricalLigatureshistoricalFormsoldstyleFigurespainting TextStylelocaleboolenable slashedZero liningFigurestabularFigurescontextualAlternatescharacterVariantscientificInferiors superscripts subscriptsproportionalFiguresvoidByteData codeUnitseverycisetUint8 codeUnitAtsetInt32_kFakeHostEndianObject runtimeTypefeaturevaluehash currentlybinary32 setFloat32axis lerpDouble clampDoublegetGlyphInfoAtgetClosestGlyphInfoForOffsetOffsetRectfromLTRBstartendltrrtl identicalgraphemeClusterLayoutBoundsgraphemeClusterCodeUnitRangewritingDirection decoration_maskhashCodeaddjoinapplyHeightToFirstAscentapplyHeightToLastDescentleadingDistribution proportionaleven Int32ListColorLocalePaintShadow isNotEmptycolor foregrounddecorationColordecorationStyledecorationThickness fontWeight fontStyle textBaseline fontFamilyfontFamilyFallback letterSpacing wordSpacing backgroundshadows fontFeaturesfontVariations_leadingDistribution _fontFamily _fontSize_letterSpacing _wordSpacing_height_decorationThickness_locale _background _foreground_encoded_shadows_fontFamilyFallback _fontFeatures_fontVariationshashAllvalues_encodelayout textAlign textDirectionmaxLinestextHeightBehavior strutStyleellipsis _strutStyle _ellipsis _fromEncodedsetInt8viewbufferleadingforceStrutHeight lengthInBytes asInt8ListDirectionality MaterialAppof BuildContextCanvas EdgeInsetsEdgeInsetsDirectionallefttoprightbottom directiontoStringAsFixed downstreamoffsetaffinity substringnewwidthgetBoxesForRangeincludeLineSpacingTopincludeLineSpacingMiddleincludeLineSpacingBottomaddPlaceholdercomputeLineMetrics longestLine hardBreakascentdescentunscaledAscentbaseline lineNumber drawParagraphboxHeightStyle boxWidthStyletightNativeFieldWrapperClass1NativeDoublePointerVoidsymbolisLeafBool Float32List fromLTRBDtoIntHandleUint32dxdyFunctionupstreamisValid _NativeCanvas Float64ListInt32 StateError aboveBaseline belowBaseline_enabledgetInt8addAll _kEncodedSize variation_objects_data_encodeShadows ArgumentErrorbaselineOffsetscale alphabeticFuture Uint8List _futurize _Callbackcallbackthenutf8encodejson asByteDataFutureOrPlatformDispatcherinstanceonPlatformMessage_invoke3PlatformMessageResponseCallback_onPlatformMessageZonechannelBufferspushNativeFieldWrapperClass1 ParagraphParagraphBuilderٚ) )&]<gh΋ϋ,ejk M6TZ<֐&sDdʑݑAEFRhܒ0Lh/q7x|ϕӖ#.2@Dǖ˗J^8yșTZәB"#uAY^-t6^(mFV\06FL$*i6tzƥ_VΧԨAG\,mWioѫVͫӬ^ڬ'nȮOٯbҰu{ f0p̳ #8G̵"(m hnҶK1Ib׸ݹgDJ $4:ѻҼ LҼBlrɾ ?io;ӿ/AGW]@ @K@L@q@w@AAOAoAuABBB\BbBwBCC3C9CCDDDD.D4DDDDDEGEEEEF#F)FjFFG<GGH HLHHIIIQIWIlIIJ:JyJJJK2KsKKKL_LeLLLLLMPMMMMN NPNNOObO}OOOOP)PcPiPPQ.Q@QFQVQ\QQQR!R'RdRRS4SzSST0T6TzTUUHUUVVV$VTVVVVW WYWWXEXKXXYY Y&Y6Y<YYZZhZiZZ[#[b[h[[\/\5\J\\\\]9]~]]]^^ ^i^o^^^^__V____`)`p```aaJaPaabb#b)b9b?bbbbccIccdd_dkdqdddde4e_eeeef,f>fDfTfZffg+g,gdgjggh1h7hvh|hhiiirixiiijjj\jjjjk+kXk^kkkkkl?llm mMmtmzmmnEnWn]nmnsnoooNoToopGpgpmpppqqqqnqqqqrr\rrrs$s*s?ssttJttttuBuHuuuuuvDvvvw wwZwwxx x_xexzxxxyJyPyyyyyz;zzzz{{D{J{{{{||X||}}_}}}}~~"~~~~S]c);AQW9i^d*0ExW9? N`f.4I kqT P:xT!' g(. Z`8z8>$hi KQfFL!'7=#BCbz{J8Y_ou%m /[ou+egh>BSWc`GK8hn>DEH'-u{llm?E6B/MSPScnohz<=bh&swxNcd,"scO-O.4Vtg(yB'w]}"(BQ¨¯³´Eim{>āę9:ŮSƛƜVǦ23sȣȤ 0Rekɉ#Z^_knpqˡOWX̛̑̚,AGͣͤ͘06΂΋Ό krtuϣϷ^mopПж,qуѾ  ~Ҧ12aӢӣ :}~Ԋԭ()5KaՅՋշ+IOy֚֠־-134e׀טסע׷ '.01^} )/Q0EUVڟ=Cۑۜۢ%-/0[ܜܠnݹDy,-\b߰'u9HNSYZ-d `[a9?17+{?~ OmFZ`PTUav>QU6I_c')*vyA*-{;>wz:Jh/Sg!HLu &?ae+/Kd>Bg"<Vz~:>Vp(LPl 'Aei04BFk g7_T1l  W   Z h z      7 W o      % 9 P g     =      >Sg~(=Of1X{"=b *Ha"PNz&dO59:F[;Wj<XP$(<   !!"3"#G#l#$E$%Y%&m&'' ' ' 'Q'T'''((Z(((((()+).)b)e))))**.*N*_*u*****++%+7+;+++++,,,>,B,^,w,,,,,,--)-C-G-k-----...-.F.j.n.//=/V/z/~/////004080P0j0000001,1C1n1t12 2Z22233[33347445(5d556 6P6V6667A778$8v8889)9/9~9: ::Z:p:v:::;1;};;; >>T>g>>>>>>?$?@?Z?v?????@@@0@A@^@s@@@@@@AA!ABA_AxAABB!B<BUBvBBBBBCC2CECKCwCCCCDD,DXDDDEEEE*EEEEEFgFGQGH;H`HI+IJJJKtKKKKKLFLLM7MMMNN=NTNjNNNNNOO)OEOOP)PEP]PwPPPPQQQ Q!Q_QQQQQR RR*RARoRRRRSS"S#SeSfSSSSSTTTWTkToTTTTTUU,U0U1UMUNUiUUUUUUVlVpVVVWWWWgWWXXXXiXXYMYYZ7ZZZZ[L[[\(\.\w\]]`]v]|]]]^4^F^L^^_=__`3`~`````a'a<aXaraaaaabb"b4bIb]bxbbbcccMcjcccddd d0dRdedkddddde:eeeeefmfnfpfqfffg<ggggh8hhhhhiiRiij=jWj[jjkJkkl(lplllm/m~mmnNnnnoo^oop9phplpppq+q/q|qqqrrrRrVrrs;sst ttMtQttuCuuvvvfvwwNwwwx+x=xxxxxy;yByDyEynyryyzz#z2z@zPzazuzzz{zz{{-{.{R{f{g{{||||B|Y|Z||||}$}%}}}}}}~9~=~>~~~~PTUa!?[{ ,$TX=5bfS@ [c#$r28!5CEFjnP)nO5Lfe(wP>`1578gy5;0Gc}~-Kcyz17x `  Bkl8Rrvw1Sfl!&'3qstEf $*+|#t [4:!Dp  VXYlQWFQa*+u{]cQW>QZ\]  l%PV   ]a@Vbc6L]^5K\]/67ag;JN.24Oq"3E^o8PQ =C>ZRy,u.V\lrOU¤¥TxÑÒ@XYeĈĴ8\ŎŰ?CDPIvDZ,[ȎȒȔȕȮȲ*.lpɿ$*[opʬʲJv|˭8>ȍ̐,LM͐+`΂΃$qσω  PVУ!oѸ>Dҝ"wlrԺDq՜՝/ց Xׇ׻׼ V؁؇QR٠@Aڈڎ*z!rS݈݇<Bގ޲8]c߇ߍEF  EK-OUDhn U#OP"pA]c9VWc=`amc$%1)PQ]W~%Z},6<NRS_hlm~M eij/0<& -^59:I8 Z:'(xA3hDs/fpw12>&UY+CV`ptu+GHbco\`am 2Zbu     b f    " q      ]     Q R       Q W t    +|l.4=>'dQ,'w?Qtz'|!'(y*,-'_ N| Iz  ! C K _ w    !!'!M!V!Z![!!""2"K"q"""""""# #)#*#6#r#####$$M$z$$%%!%"%P%%&7&8&&&&''A'a''( (u((((()!)C)))*i********++>+X++++, ,),V,q,,,,,,,,,- ----?-Q-c-u-----. .%.<.\.q.....//-/S/q/////000+00000011)1/1314111122/2K2g2n223<33414`455&5*5+5666&6<6y6666675767B7m7o7p7778D88899S9f9l9999::::K::;;7;q;;;;;<:<><@h,/// The thickness value of this font weight.rP/// Thin, the least thick.F/// Extra-light.  @7 /// Light.>HIJQKNWS/// Normal / regular / plain.A /// Medium.܉D/// Semi-bold.%/01825>?b /// Bold.istu|vyE/// Extra-bold.ƊÊP/// Black, the most thick.!DX/// The default font weight.ajb], such as /// an [AnimationController].~ HN[HI̗P/// A feature tag and value that affect the selection of glyphs in a font. /// /// Different fonts support different features. Consider using a tool /// such as to examine your fonts to /// determine what features are available. /// /// {@tool sample} /// This example shows usage of several OpenType font features, /// including Small Caps (selected manually using the "smcp" code), /// old-style figures, fractional ligatures, and stylistic sets. /// /// ** See code in examples/api/lib/ui/text/font_feature.0.dart ** /// {@end-tool} /// /// Some fonts also support continuous font variations; see the [FontVariation] /// class. /// /// See also: /// /// * , /// Wikipedia's description of these typographic features. /// /// * , /// Microsoft's registry of these features.`07/// Creates a [FontFeature] object, which can be added to a [TextStyle] to /// change how the engine selects glyphs when rendering text. /// /// `feature` is the four-character tag that identifies the feature. /// These tags are specified by font formats such as OpenType. /// /// `value` is the value that the feature will be set to. The behavior /// of the value depends on the specific feature. Many features are /// flags whose value can be 1 (when enabled) or 0 (when disabled). /// /// See   ? HNYUOX[N/// Create a [FontFeature] object that enables the feature with the given tag.%O/// Create a [FontFeature] object that disables the feature with the given tag.Z/// Access alternative glyphs. (`aalt`) /// /// This feature selects the given glyph variant for glyphs in the span. /// /// {@tool sample} /// The Raleway font supports several alternate glyphs. The code /// below shows how specific glyphs can be selected. With `aalt` set /// to zero, the default, the normal glyphs are used. With a /// non-zero value, Raleway substitutes small caps for lower case /// letters. With value 2, the lowercase "a" changes to a stemless /// "a", whereas the lowercase "t" changes to a vertical bar instead /// of having a curve. By targeting specific letters in the text /// (using [widgets.Text.rich]), the desired rendering for each glyph can be /// achieved. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_aalt.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_alternative.0.dart ** /// {@end-tool} /// /// See also: /// /// *  آТڢ儺ij~D/// Use alternative ligatures to represent fractions. (`afrc`) /// /// When this feature is enabled (and the font supports it), /// sequences of digits separated by U+002F SOLIDUS character (/) or /// U+2044 FRACTION SLASH (⁄) are replaced by ligatures that /// represent the corresponding fraction. These ligatures may differ /// from those used by the [FontFeature.fractions] feature. /// /// This feature overrides all other features. /// /// {@tool sample} /// The Ubuntu Mono font supports the `afrc` feature. It causes digits /// before slashes to become superscripted and digits after slashes to become /// subscripted. This contrasts to the effect seen with [FontFeature.fractions]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_afrc.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_alternative_fractions.0.dart ** /// {@end-tool} /// /// See also: /// /// * [FontFeature.fractions], which has a similar (but different) effect. /// * ij~/// Enable contextual alternates. (`calt`) /// /// With this feature enabled, specific glyphs may be replaced by /// alternatives based on nearby text. /// /// {@tool sample} /// The Barriecito font supports the `calt` feature. It causes some /// letters in close proximity to other instances of themselves to /// use different glyphs, to give the appearance of more variation /// in the glyphs, rather than having each letter always use a /// particular glyph. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_calt.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_contextual_alternates.0.dart ** /// {@end-tool} /// /// See also: /// /// * [FontFeature.randomize], which is more a rarely supported but more /// powerful way to get a similar effect. /// *  yz/// Enable case-sensitive forms. (`case`) /// /// Some glyphs, for example parentheses or operators, are typically /// designed to fit nicely with mixed case, or even predominantly /// lowercase, text. When these glyphs are placed near strings of /// capital letters, they appear a little off-center. /// /// This feature, when supported by the font, causes these glyphs to /// be shifted slightly, or otherwise adjusted, so as to form a more /// aesthetically pleasing combination with capital letters. /// /// {@tool sample} /// The Piazzolla font supports the `case` feature. It causes /// parentheses, brackets, braces, guillemets, slashes, bullets, and /// some other glyphs (not shown below) to be shifted up slightly so /// that capital letters appear centered in comparison. When the /// feature is disabled, those glyphs are optimized for use with /// lowercase letters, and so capital letters appear to ride higher /// relative to the punctuation marks. /// /// The difference is very subtle. It may be most obvious when /// examining the square brackets compared to the capital A. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_case.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_case_sensitive_forms.0.dart ** /// {@end-tool} /// /// See also: /// /// * #/// Select a character variant. (`cv01` through `cv99`) /// /// Fonts may have up to 99 character variant sets, numbered 1 /// through 99, each of which can be independently enabled or /// disabled. /// /// Related character variants are typically grouped into stylistic /// sets, controlled by the [FontFeature.stylisticSet] feature /// (`ssXX`). /// /// {@tool sample} /// The Source Code Pro font supports the `cvXX` feature for several /// characters. In the example below, variants 1 (`cv01`), 2 /// (`cv02`), and 4 (`cv04`) are selected. Variant 1 changes the /// rendering of the "a" character, variant 2 changes the lowercase /// "g" character, and variant 4 changes the lowercase "i" and "l" /// characters. There are also variants (not shown here) that /// control the rendering of various greek characters such as beta /// and theta. /// /// Notably, this can be contrasted with the stylistic sets, where /// the set which affects the "a" character also affects beta, and /// the set which affects the "g" character also affects theta and /// delta. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_cvXX.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_character_variant.0.dart ** /// {@end-tool} /// /// See also: /// /// * [FontFeature.stylisticSet], which allows for groups of characters /// variants to be selected at once, as opposed to individual character variants. /// * $ )&/// Display digits as denominators. (`dnom`) /// /// This is typically used automatically by the font rendering /// system as part of the implementation of `frac` for the denominator /// part of fractions (see [FontFeature.fractions]). /// /// {@tool sample} /// The Piazzolla font supports the `dnom` feature. It causes /// the digits to be rendered smaller and near the bottom of the EM box. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_dnom.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_denominator.0.dart ** /// {@end-tool} /// /// See also: /// /// * ̻ƻλԄv@@ @) /// Use ligatures to represent fractions. (`afrc`) /// /// When this feature is enabled (and the font supports it), /// sequences of digits separated by U+002F SOLIDUS character (/) or /// U+2044 FRACTION SLASH (⁄) are replaced by ligatures that /// represent the corresponding fraction. /// /// This feature may imply the [FontFeature.numerators] and /// [FontFeature.denominator] features. /// /// {@tool sample} /// The Ubuntu Mono font supports the `frac` feature. It causes /// digits around slashes to be turned into dedicated fraction /// glyphs. This contrasts to the effect seen with /// [FontFeature.alternativeFractions]. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_frac.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_fractions.0.dart ** /// {@end-tool} /// /// See also: /// /// * [FontFeature.alternativeFractions], which has a similar (but different) effect. /// * @6@.@8@F@@@H@NDDD /// Use historical forms. (`hist`) /// /// Some fonts have alternatives for letters whose forms have changed /// through the ages. In the Latin alphabet, this is common for /// example with the long-form "s" or the Fraktur "k". This feature enables /// those alternative glyphs. /// /// This does not enable legacy ligatures, only single-character alternatives. /// To enable historical ligatures, use [FontFeature.historicalLigatures]. /// /// This feature may override other glyph-substitution features. /// /// {@tool sample} /// The Cardo font supports the `hist` feature specifically for the /// letter "s": it changes occurrences of that letter for the glyph /// used by U+017F LATIN SMALL LETTER LONG S. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_historical.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_historical_forms.0.dart ** /// {@end-tool} /// /// See also: /// /// * DDDDDDD҈McMdMw//// Use historical ligatures. (`hlig`) /// /// Some fonts support ligatures that have fallen out of favor today, /// but were historically in common use. This feature enables those /// ligatures. /// /// For example, the "long s" glyph was historically typeset with /// characters such as "t" and "h" as a single ligature. /// /// This does not enable the legacy forms, only ligatures. See /// [FontFeature.historicalForms] to enable single characters to be /// replaced with their historical alternatives. Combining both is /// usually desired since the ligatures typically apply specifically /// to characters that have historical forms as well. For example, /// the historical forms feature might replace the "s" character /// with the "long s" (ſ) character, while the historical ligatures /// feature might specifically apply to cases where "long s" is /// followed by other characters such as "t". In such cases, without /// the historical forms being enabled, the ligatures would only /// apply when the "long s" is used explicitly. /// /// This feature may override other glyph-substitution features. /// /// {@tool sample} /// The Cardo font supports the `hlig` feature. It has legacy /// ligatures for "VI" and "NT", and various ligatures involving the /// "long s". In the example below, both historical forms (`hist 1`) /// and historical ligatures (`hlig 1`) are enabled, so, for /// instance, "fish" becomes "fiſh" which is then rendered using a /// ligature for the last two characters. /// /// Similarly, the word "business" is turned into "buſineſſ" by /// `hist`, and the `ſi` and `ſſ` pairs are ligated by `hlig`. /// Observe in particular the position of the dot of the "i" in /// "business" in the various combinations of these features. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_historical.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_historical_ligatures.0.dart ** /// {@end-tool} /// /// See also: /// /// * MM|MMMMMXQQQӃ/// Use lining figures. (`lnum`) /// /// Some fonts have digits that, like lowercase latin letters, have /// both descenders and ascenders. In some situations, especially in /// conjunction with capital letters, this leads to an aesthetically /// questionable irregularity. Lining figures, on the other hand, /// have a uniform height, and align with the baseline and the /// height of capital letters. Conceptually, they can be thought of /// as "capital digits". /// /// This feature may conflict with [FontFeature.oldstyleFigures]. /// /// {@tool sample} /// The Sorts Mill Goudy font supports the `lnum` feature. It causes /// digits to fit more seamlessly with capital letters. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_lnum.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_lining_figures.0.dart ** /// {@end-tool} /// /// See also: /// /// * QQQQQQQoZZZ#/// Use locale-specific glyphs. (`locl`) /// /// Some characters, most notably those in the Unicode Han /// Unification blocks, vary in presentation based on the locale in /// use. For example, the ideograph for "grass" (U+8349, 草) has a /// broken top line in Traditional Chinese, but a solid top line in /// Simplified Chinese, Japanese, Korean, and Vietnamese. This kind /// of variation also exists with other alphabets, for example /// Cyrillic characters as used in the Bulgarian and Serbian /// alphabets vary from their Russian counterparts. /// /// A particular font may default to the forms for the locale for /// which it was constructed, but still support alternative forms /// for other locales. When this feature is enabled, the locale (as /// specified using [painting.TextStyle.locale], for instance) is /// used to determine which glyphs to use when locale-specific /// alternatives exist. Disabling this feature causes the font /// rendering to ignore locale information and only use the default /// glyphs. /// /// This feature is enabled by default. Using /// `FontFeature.localeAware(enable: false)` disables the /// locale-awareness. (So does not specifying the locale in the /// first place, of course.) /// /// {@tool sample} /// The Noto Sans CJK font supports the `locl` feature for CJK characters. /// In this example, the `localeAware` feature is not explicitly used, as it is /// enabled by default. This example instead shows how to set the locale, /// thus demonstrating how Noto Sans adapts the glyph shapes to the locale. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_locl.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_locale_aware.0.dart ** /// {@end-tool} /// /// See also: /// /// * /// * /// * Z&Z, Z4ZFZ>ZHZVZPZ_ZcZXZaZeZkH_i_j_y/// Display alternative glyphs for numerals (alternate annotation forms). (`nalt`) /// /// Replaces glyphs used in numbering lists (e.g. 1, 2, 3...; or a, b, c...) with notational /// variants that might be more typographically interesting. /// /// Fonts sometimes support multiple alternatives, and the argument /// selects the set to use (a positive integer, or 0 to disable the /// feature). The default set if none is specified is 1. /// /// {@tool sample} /// The Gothic A1 font supports several notational variant sets via /// the `nalt` feature. /// /// Set 1 changes the spacing of the glyphs. Set 2 parenthesizes the /// latin letters and reduces the numerals to subscripts. Set 3 /// circles the glyphs. Set 4 parenthesizes the digits. Set 5 uses /// reverse-video circles for the digits. Set 7 superscripts the /// digits. /// /// The code below shows how to select set 3. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_nalt.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_notational_forms.0.dart ** /// {@end-tool} /// /// See also: /// /// * _{_ ___________bbb/// Display digits as numerators. (`numr`) /// /// This is typically used automatically by the font rendering /// system as part of the implementation of `frac` for the numerator /// part of fractions (see [FontFeature.fractions]). /// /// {@tool sample} /// The Piazzolla font supports the `numr` feature. It causes /// the digits to be rendered smaller and near the top of the EM box. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_numr.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_numerators.0.dart ** /// {@end-tool} /// /// See also: /// /// * bbbbbbb؄Rffg /// Use old style figures. (`onum`) /// /// Some fonts have variants of the figures (e.g. the digit 9) that, /// when this feature is enabled, render with descenders under the /// baseline instead of being entirely above the baseline. If the /// default digits are lining figures, this allows the selection of /// digits that fit better with mixed case (uppercase and lowercase) /// text. /// /// This overrides [FontFeature.slashedZero] and may conflict with /// [FontFeature.liningFigures]. /// /// {@tool sample} /// The Piazzolla font supports the `onum` feature. It causes /// digits to extend below the baseline. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_onum.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_oldstyle_figures.0.dart ** /// {@end-tool} /// /// See also: /// /// * /// * gggg&g g(g.ojojpj|/// Use ordinal forms for alphabetic glyphs. (`ordn`) /// /// Some fonts have variants of the alphabetic glyphs intended for /// use after numbers when expressing ordinals, as in "1st", "2nd", /// "3rd". This feature enables those alternative glyphs. /// /// This may override other features that substitute glyphs. /// /// {@tool sample} /// The Piazzolla font supports the `ordn` feature. It causes /// alphabetic glyphs to become smaller and superscripted. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_ordn.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_ordinal_forms.0.dart ** /// {@end-tool} /// /// See also: /// /// * jjjjjjjpnnn/// Use proportional (varying width) figures. (`pnum`) /// /// For fonts that have both proportional and tabular (monospace) figures, /// this enables the proportional figures. /// /// This is mutually exclusive with [FontFeature.tabularFigures]. /// /// The default behavior varies from font to font. /// /// {@tool sample} /// The Kufam font supports the `pnum` feature. It causes the digits /// to become proportionally-sized, rather than all being the same /// width. In this font this is especially noticeable with the digit /// "1": normally, the 1 has very noticeable serifs in this /// sans-serif font, but with the proportionally figures enabled, /// the digit becomes much narrower. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_pnum.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_proportional_figures.0.dart ** /// {@end-tool} /// /// See also: /// /// * nnno oooqqq>/// Randomize the alternate forms used in text. (`rand`) /// /// For example, this can be used with suitably-prepared handwriting fonts to /// vary the forms used for each character, so that, for instance, the word /// "cross-section" would be rendered with two different "c"s, two different "o"s, /// and three different "s"s. /// /// Contextual alternates ([FontFeature.contextualAlternates]) /// provide a similar effect in some fonts, without using /// randomness. /// /// See also: /// /// * qqqqqqq2vvv/// Enable stylistic alternates. (`salt`) /// /// Some fonts have alternative forms that are not tied to a /// particular purpose (such as being historical forms, or /// contextually relevant alternatives, or ligatures, etc). This /// font feature enables these purely stylistic alternatives. /// /// This may override other features that substitute glyphs. /// /// {@tool sample} /// The Source Code Pro font supports the `salt` feature. It causes /// some glyphs to be rendered differently, for example the "a" and /// "g" glyphs change from their typographically common /// double-storey forms to simpler single-storey forms, the dollar /// sign's line changes from discontinuous to continuous (and is /// angled), and the "0" rendering changes from a center dot to a /// slash. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_salt.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_stylistic_alternates.0.dart ** /// {@end-tool} /// /// See also: /// /// * [FontFeature.contextualAlternates], which is enables alternates specific to certain contexts. /// * vvvvvvv惝zNzOzb,/// Use scientific inferiors. (`sinf`) /// /// Some fonts have variants of the figures (e.g. the digit 2) that, /// when this feature is enabled, render in a manner more /// appropriate for subscripted digits ("inferiors") used in /// scientific contexts, e.g. the subscripts in chemical formulae. /// /// This may override other features that substitute glyphs. /// /// {@tool sample} /// The Piazzolla font supports the `sinf` feature. It causes /// digits to be smaller and subscripted. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_sinf.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_scientific_inferiors.0.dart ** /// {@end-tool} /// /// See also: /// /// * zozgzqzzyzzWNO[[/// Select a stylistic set. (`ss01` through `ss20`) /// /// Fonts may have up to 20 stylistic sets, numbered 1 through 20, /// each of which can be independently enabled or disabled. /// /// For more fine-grained control, in some fonts individual /// character variants can also be controlled by the /// [FontFeature.characterVariant] feature (`cvXX`). /// /// {@tool sample} /// The Source Code Pro font supports the `ssXX` feature for several /// sets. In the example below, stylistic sets 2 (`ss02`), 3 /// (`ss03`), and 4 (`ss04`) are selected. Stylistic set 2 changes /// the rendering of the "a" character and the beta character, /// stylistic set 3 changes the lowercase "g", theta, and delta /// characters, and stylistic set 4 changes the lowercase "i" and /// "l" characters. /// /// This font also supports character variants (see /// [FontFeature.characterVariant]). /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_ssXX_1.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_stylistic_set.0.dart ** /// {@end-tool} /// /// {@tool sample} /// The Piazzolla font supports the `ssXX` feature for more /// elaborate stylistic effects. Set 1 turns some Latin characters /// into Roman numerals, set 2 enables some ASCII characters to be /// used to create pretty arrows, and so forth. /// /// _These_ stylistic sets do _not_ correspond to character variants. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_ssXX_2.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_stylistic_set.1.dart ** /// {@end-tool} /// /// See also: /// /// * [FontFeature.characterVariant], which allows for individual character /// variants to be selected, as opposed to entire sets. /// * \ a1/// Enable subscripts. (`subs`) /// /// This feature causes some fonts to change some glyphs to their subscripted form. /// /// It typically does not affect all glyphs, and so is not appropriate for generally causing /// all text to be subscripted. /// /// This may override other features that substitute glyphs. /// /// {@tool sample} /// The Piazzolla font supports the `subs` feature. It causes /// digits to be smaller and subscripted. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_subs.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_subscripts.0.dart ** /// {@end-tool} /// /// See also: /// /// * /// * [FontFeature.scientificInferiors], which is similar but intended specifically for /// subscripts used in scientific contexts. /// * [FontFeature.superscripts], which is similar but for subscripting. R/// Enable superscripts. (`sups`) /// /// This feature causes some fonts to change some glyphs to their /// superscripted form. This may be more than just changing their /// position. For example, digits might change to lining figures /// (see [FontFeature.liningFigures]) in addition to being raised /// and shrunk. /// /// It typically does not affect all glyphs, and so is not /// appropriate for generally causing all text to be superscripted. /// /// This may override other features that substitute glyphs. /// /// {@tool sample} /// The Sorts Mill Goudy font supports the `sups` feature. It causes /// digits to be smaller, superscripted, and changes them to lining /// figures (so they are all the same height). /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_sups.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_superscripts.0.dart ** /// {@end-tool} /// /// See also: /// /// * /// * [FontFeature.subscripts], which is similar but for subscripting./// Enable swash glyphs. (`swsh`) /// /// Some fonts have beautiful flourishes on some characters. These /// come in many forms, such as exaggerated serifs, long tails, long /// entry strokes, or other forms of decorative extensions to the /// base character. /// /// This feature enables the rendering of these flourishes. Some /// fonts have many swashes per character; the argument, if /// specified, selects which swash to use (0 disables them /// altogether). /// /// Some fonts have an absurd number of alternative swashes. For /// example, Adobe's Poetica famously has 63 different ampersand /// forms available through this feature! /// /// {@tool sample} /// The BioRhyme Expanded font supports the `swsh` feature specifically /// for the capital "Q" and "R" glyphs and the ampersand. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_swsh.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_swash.0.dart ** /// {@end-tool} /// /// See also: /// /// * /// *  m78F/// Use tabular (monospace) figures. (`tnum`) /// /// For fonts that have both proportional (varying width) and tabular figures, /// this enables the tabular figures. Tabular figures are monospaced (all the /// same width), so that they align in tables of figures. /// /// This is mutually exclusive with [FontFeature.proportionalFigures]. /// /// The default behavior varies from font to font. /// /// {@tool sample} /// The Piazzolla font supports the `tnum` feature. It causes the /// digits to become uniformly-sized, rather than having variable /// widths. In this font this is especially noticeable with the /// digit "1"; with tabular figures enabled, the "1" digit is more /// widely spaced. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_tnum.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_tabular_figures.0.dart ** /// {@end-tool} /// /// See also: /// /// * SKUc]ekh/// Use the slashed zero. (`zero`) /// /// Some fonts contain both a circular zero and a zero with a slash. This /// enables the use of the latter form. /// /// This is overridden by [FontFeature.oldstyleFigures]. /// /// {@tool sample} /// The Source Code Pro font supports the `zero` feature. It causes the /// zero digit to be drawn with a slash rather than the default rendering, /// which in this case has a dot through the zero rather than a slash. /// /// ![](https://flutter.github.io/assets-for-api-docs/assets/dart-ui/font_feature_zero.png) /// /// ** See code in examples/api/lib/ui/text/font_feature.font_feature_slashed_zero.0.dart ** /// {@end-tool} /// /// See also: /// /// * E3q/// The tag that identifies the effect of this feature. Must consist of 4 /// ASCII characters (typically lowercase letters). /// /// These features are defined in a registry maintained by Microsoft: /// }Z҂2/// The value assigned to this feature. /// /// Must be a positive integer. Many features are Boolean values that accept /// values of either 0 (feature is disabled) or 1 (feature is enabled). Other /// features have a bound range of values (which may be documented in these /// API docs for features that have dedicated constructors, and are generally /// documented in the official registry). In some cases the precise supported /// range depends on the font. /// /// See also: /// /// * "< '!C4!"hكj/// An axis tag and value that can be used to customize variable fonts. /// /// Some fonts are variable fonts that can generate a range of different /// font faces by altering the values of the font's design axes. /// /// For example: /// /// ```dart /// const TextStyle(fontVariations: [ui.FontVariation('wght', 800.0)]) /// ``` /// /// Font variations are distinct from font features, as exposed by the /// [FontFeature] class. Where features can be enabled or disabled in a discrete /// manner, font variations provide a continuous axis of control. /// /// See also: /// /// * , /// which lists registered axis tags. /// /// * , /// an overview of the font variations technology. ҁ/// Creates a [FontVariation] object, which can be added to a [TextStyle] to /// change the variable attributes of a font. /// /// `axis` is the four-character tag that identifies the design axis. /// OpenType lists the [currently registered axis /// tags](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg). /// /// `value` is the value that the axis will be set to. The behavior /// depends on how the font implements the axis. B KQvdXR[\mgoxf"/// Variable font style. (`ital`) /// /// Varies the style of glyphs in the font between normal and italic. /// /// Values must in the range 0.0 (meaning normal, or Roman, as in /// [FontStyle.normal]) to 1.0 (meaning fully italic, as in /// [FontStyle.italic]). /// /// This is distinct from [FontVariation.slant], which leans the characters /// without changing the font style. /// /// See also: /// /// * # )17D>8AGMZTNWb]do4efq/// Optical size optimization. (`opzs`) /// /// Changes the rendering of the font to be optimized for the given text size. /// Normally, the optical size of the font will be derived from the font size. /// /// This feature could be used when the text represents a particular physical /// font size, for example text in the representation of a hardcopy magazine, /// which does not correspond to the actual font size being used to render the /// text. By setting the optical size explicitly, font variations that might /// be applied as the text is zoomed will be fixed at the size being /// represented by the text. /// /// This feature could also be used to smooth animations. If a font varies its /// rendering as the font size is adjusted, it may appear to "quiver" (or, one /// might even say, "flutter") if the font size is animated. By setting a /// fixed optical size, the rendering can be fixed to one particular style as /// the text size animates. /// /// Values must be greater than zero, and are interpreted as points. A point /// is 1/72 of an inch, or 1.333 logical pixels (96/72). /// /// See also: /// /// * r x #B/// Variable font width. (`slnt`) /// /// Varies the slant of glyphs in the font. /// /// Values must be greater than -90.0 and less than +90.0, and represents the /// angle in _counter-clockwise_ degrees relative to "normal", at 0.0. /// /// For example, to lean the glyphs forward by 45 degrees, one would use /// `FontVariation.slant(-45.0)`. /// /// This is distinct from [FontVariation.italic], in that slant leans the /// characters without changing the font style. /// /// See also: /// /// * $ *28F?9ABIO\VPXd_fqg/// Variable font width. (`wdth`) /// /// Varies the width of glyphs in the font. /// /// Values must be greater than zero, with no upper limit. 100.0 represents /// the "normal" width. Smaller values are "condensed", greater values are /// "extended". /// /// See also: /// /// *   *$'2-4?7'(./// Variable font weight. (`wght`) /// /// Varies the stroke thickness of the font, similar to [FontWeight] but on a /// continuous axis. /// /// Values must be in the range 1..1000, and are to be interpreted in a manner /// consistent with the values of [FontWeight]. For instance, `400` is the /// "normal" weight, and `700` is "bold". /// /// See also: /// /// * / 5=CNJDMQWe^Xamho|]d/// The tag that identifies the design axis. /// /// An axis tag must consist of 4 ASCII characters.f4/// The value assigned to this design axis. /// /// The range of usable values depends on the specification of the axis. /// /// While this property is represented as a [double] in this API /// ([binary64](https://en.wikipedia.org/wiki/Double-precision_floating-point_format)), /// fonts use the fixed-point 16.16 format to represent the value of font /// variations. This means that the actual range is -32768.0 to approximately /// 32767.999985 and in principle the smallest increment between two values is /// approximately 0.000015 (1/65536). /// /// Unfortunately for technical reasons the value is first converted to the /// [binary32 floating point /// format](https://en.wikipedia.org/wiki/Single-precision_floating-point_format), /// which only has 24 bits of precision. This means that for values outside /// the range -256.0 to 256.0, the smallest increment is larger than what is /// technically supported by OpenType. At the extreme edge of the range, the /// smallest increment is only approximately ±0.002."9ƀ م{/// Linearly interpolates between two font variations. /// /// If the two variations have different axis tags, the interpolation switches /// abruptly from one to the other at t=0.5. Otherwise, the value is /// interpolated (see [lerpDouble]. /// /// The value is not clamped to the valid values of the axis tag, but it is /// clamped to the valid range of font variations values in general (the range /// of signed 16.16 fixed point numbers). /// /// The `t` argument represents position on the timeline, with 0.0 meaning /// that the interpolation has not started, returning `a` (or something /// equivalent to `a`), 1.0 meaning that the interpolation has finished, /// returning `b` (or something equivalent to `b`), and values in between /// meaning that the interpolation is at the relevant point on the timeline /// between `a` and `b`. The interpolation can be extrapolated beyond 0.0 and /// 1.0, so negative values and values greater than 1.0 are valid (and can /// easily be generated by curves such as [Curves.elasticInOut]). /// /// Values for `t` are usually obtained from an [Animation], such as /// an [AnimationController].¶B¶·sč/// The measurements of a character (or a sequence of visually connected /// characters) within a paragraph. /// /// See also: /// /// * [Paragraph.getGlyphInfoAt], which finds the [GlyphInfo] associated with /// a code unit in the text. /// * [Paragraph.getClosestGlyphInfoForOffset], which finds the [GlyphInfo] of /// the glyph(s) onscreen that's closest to the given [Offset].ě4/// Creates a [GlyphInfo] with the specified values. !!'<^EFGH PU ]a io w~ŃőŖŢ Ũ!Ŵ )P/*1C@EjYrƆltƁƂƈƕƖƞ]/// The layout bounding rect of the associated character, in the paragraph's /// coordinates. /// /// This is **not** a tight bounding box that encloses the character's outline. /// The vertical extent reported is derived from the font metrics (instead of /// glyph metrics), and the horizontal extent is the horizontal advance of the /// character.5lȅ=/// The UTF-16 range of the associated character in the text.ȦX1/// The writing direction within the [GlyphInfo].ayuabZ (ހpХ./// A linear decoration to draw near the text.и# ߁+DELL/// Creates a decoration that paints the union of all the given decorations.M cW/// Do not draw a decoration()*.+4l,/// Draw a line underneath each line of textӋәӚӛӟӜӥf'/// Draw a line above each line of text kX)/// Draw a line through each line of textftuvzw/ "҅[/// Whether this decoration will paint at least as much decoration as the given decoration.ҎҞԀtԚԝ ԥԀԁ+>+,0/// {@template dart.ui.textHeightBehavior} /// Defines how to apply [TextStyle.height] over and under text. /// /// [TextHeightBehavior.applyHeightToFirstAscent] and /// [TextHeightBehavior.applyHeightToLastDescent] represent whether the /// [TextStyle.height] modifier will be applied to the corresponding metric. By /// default both properties are true, and [TextStyle.height] is applied as /// normal. When set to false, the font's default ascent will be used. /// /// [TextHeightBehavior.leadingDistribution] determines how the /// leading is distributed over and under text. This /// property applies before [TextHeightBehavior.applyHeightToFirstAscent] and /// [TextHeightBehavior.applyHeightToLastDescent]. /// /// {@endtemplate}/)᷂W/// Creates a new TextHeightBehavior object. /// /// * applyHeightToFirstAscent: When true, the [TextStyle.height] modifier /// will be applied to the ascent of the first line. When false, the font's /// default ascent will be used. /// * applyHeightToLastDescent: When true, the [TextStyle.height] modifier /// will be applied to the descent of the last line. When false, the font's /// default descent will be used. /// * leadingDistribution: How the leading is distributed over and under /// text. /// /// All properties default to true (height modifications applied as normal).$$?-DE\>}/// Creates a new TextHeightBehavior object from an encoded form. /// /// See [_encode] for the creation of the encoded form. L3^N\WOYaj㞂)寁/// Whether to apply the [TextStyle.height] modifier to the ascent of the first /// line in the paragraph. /// /// When true, the [TextStyle.height] modifier will be applied to the ascent /// of the first line. When false, the font's default ascent will be used and /// the [TextStyle.height] will have no effect on the ascent of the first line. /// /// This property only has effect if a non-null [TextStyle.height] is specified. /// /// Defaults to true (height modifications applied as normal).̂*ށ/// Whether to apply the [TextStyle.height] modifier to the descent of the last /// line in the paragraph. /// /// When true, the [TextStyle.height] modifier will be applied to the descent /// of the last line. When false, the font's default descent will be used and /// the [TextStyle.height] will have no effect on the descent of the last line. /// /// This property only has effect if a non-null [TextStyle.height] is specified. /// /// Defaults to true (height modifications applied as normal). /// {@template dart.ui.textLeadingDistribution} /// How the ["leading"](https://en.wikipedia.org/wiki/Leading) is distributed /// over and under the text. /// /// Does not affect layout when [TextStyle.height] is not specified. The /// leading can become negative, for example, when [TextLeadingDistribution.even] /// is used with a [TextStyle.height] much smaller than 1.0. /// {@endtemplate} /// /// Defaults to [TextLeadingDistribution.proportional],WkWX s_/// Returns an encoded int representation of this object (excluding /// [leadingDistribution]).f *Ȁ/// An opaque object that determines the size, position, and rendering of text. /// /// See also: /// /// * [TextStyle](https://api.flutter.dev/flutter/painting/TextStyle-class.html), the class in the [painting] library. ///֒ \ eG/// Creates a new TextStyle object. /// /// * `color`: The color to use when painting the text. If this is specified, `foreground` must be null. /// * `decoration`: The decorations to paint near the text (e.g., an underline). /// * `decorationColor`: The color in which to paint the text decorations. /// * `decorationStyle`: The style in which to paint the text decorations (e.g., dashed). /// * `decorationThickness`: The thickness of the decoration as a multiplier on the thickness specified by the font. /// * `fontWeight`: The typeface thickness to use when painting the text (e.g., bold). /// * `fontStyle`: The typeface variant to use when drawing the letters (e.g., italics). /// * `fontFamily`: The name of the font to use when painting the text (e.g., Roboto). If a `fontFamilyFallback` is /// provided and `fontFamily` is not, then the first font family in `fontFamilyFallback` will take the position of /// the preferred font family. When a higher priority font cannot be found or does not contain a glyph, a lower /// priority font will be used. /// * `fontFamilyFallback`: An ordered list of the names of the fonts to fallback on when a glyph cannot /// be found in a higher priority font. When the `fontFamily` is null, the first font family in this list /// is used as the preferred font. Internally, the 'fontFamily` is concatenated to the front of this list. /// When no font family is provided through 'fontFamilyFallback' (null or empty) or `fontFamily`, then the /// platform default font will be used. /// * `fontSize`: The size of glyphs (in logical pixels) to use when painting the text. /// * `letterSpacing`: The amount of space (in logical pixels) to add between each letter. /// * `wordSpacing`: The amount of space (in logical pixels) to add at each sequence of white-space (i.e. between each word). /// * `textBaseline`: The common baseline that should be aligned between this text span and its parent text span, or, for the root text spans, with the line box. /// * `height`: The height of this text span, as a multiplier of the font size. Setting the `height` to `kTextHeightNone` will allow the line height /// to take the height as defined by the font, which may not be exactly the height of the fontSize. /// * `leadingDistribution`: When `height` is set to a non-null that is not `kTextHeightNone`, how the extra vertical space should be distributed over and under the text. /// Defaults to the paragraph's [TextHeightBehavior] if left unspecified. /// * `locale`: The locale used to select region-specific glyphs. /// * `background`: The paint drawn as a background for the text. /// * `foreground`: The paint used to draw the text. If this is specified, `color` must be null. /// * `fontFeatures`: The font features that should be applied to the text. /// * `fontVariations`: The font variations that should be applied to the text. l  t ~    $      ! - ; J [ d s           ,  ) 2 = E T \ k z   # R             F       )G\p 1FXo%'G8Il_n2)4RDTyi{' ,:JXc"q&$*?R3q<P<= 0V12/// An opaque object that determines the configuration used by /// [ParagraphBuilder] to position lines within a [Paragraph] of text.1E>V>d/// Creates a new ParagraphStyle object. /// /// * `textAlign`: The alignment of the text within the lines of the /// paragraph. If the last line is ellipsized (see `ellipsis` below), the /// alignment is applied to that line after it has been truncated but before /// the ellipsis has been added. /// See: https://github.com/flutter/flutter/issues/9819 /// /// * `textDirection`: The directionality of the text, left-to-right (e.g. /// Norwegian) or right-to-left (e.g. Hebrew). This controls the overall /// directionality of the paragraph, as well as the meaning of /// [TextAlign.start] and [TextAlign.end] in the `textAlign` field. /// /// * `maxLines`: The maximum number of lines painted. Lines beyond this /// number are silently dropped. For example, if `maxLines` is 1, then only /// one line is rendered. If `maxLines` is null, but `ellipsis` is not null, /// then lines after the first one that overflows the width constraints are /// dropped. The width constraints are those set in the /// [ParagraphConstraints] object passed to the [Paragraph.layout] method. /// /// * `fontFamily`: The name of the font family to apply when painting the text, /// in the absence of a `textStyle` being attached to the span. /// /// * `fontSize`: The fallback size of glyphs (in logical pixels) to /// use when painting the text. This is used when there is no [TextStyle]. /// /// * `height`: The fallback height of the spans as a multiplier of the font /// size. The fallback height is used when no height is provided through /// [TextStyle.height]. Omitting `height` here (or setting it to /// [kTextHeightNone]) and in [TextStyle] will allow the line height to take /// the height as defined by the font, which may not be exactly the height of /// the `fontSize`. /// /// * `textHeightBehavior`: Specifies how the `height` multiplier is /// applied to ascent of the first line and the descent of the last line. /// /// * `leadingDistribution`: Specifies how the extra vertical space added by /// the `height` multiplier should be distributed over and under the text. /// Defaults to [TextLeadingDistribution.proportional]. /// /// * `fontWeight`: The typeface thickness to use when painting the text /// (e.g., bold). /// /// * `fontStyle`: The typeface variant to use when drawing the letters (e.g., /// italics). /// /// * `strutStyle`: The properties of the strut. Strut defines a set of minimum /// vertical line height related metrics and can be used to obtain more /// advanced line spacing behavior. /// /// * `ellipsis`: String used to ellipsize overflowing text. If `maxLines` is /// not null, then the `ellipsis`, if any, is applied to the last rendered /// line, if that line overflows the width constraints. If `maxLines` is /// null, then the `ellipsis` is applied to the first line that overflows /// the width constraints, and subsequent lines are dropped. The width /// constraints are those set in the [ParagraphConstraints] object passed to /// the [Paragraph.layout] method. The empty string and the null value are /// considered equivalent and turn off this behavior. /// /// * `locale`: The locale used to select region-specific glyphs. >k>w>>> >>>>>>>>&??(?5?D?P?^?k?z???,????@???@@&@9@J@g@|@@@@@@@@@AAAA4A(A6ASAIAUAnAfApAAAAAAAAAAABBB#B1B>BLBWBiBxBBBB2BE E4E E!B9BC CBBEEEEEUVv/// See also: /// /// * [StrutStyle](https://api.flutter.dev/flutter/painting/StrutStyle-class.html), the class in the [painting] library. ///V``/// Creates a new StrutStyle object. /// /// * `fontFamily`: The name of the font to use when painting the text (e.g., /// Roboto). /// /// * `fontFamilyFallback`: An ordered list of font family names that will be /// searched for when the font in `fontFamily` cannot be found. /// /// * `fontSize`: The size of glyphs (in logical pixels) to use when painting /// the text. /// /// * `height`: The minimum height of the line boxes, as a multiplier of the /// font size. The lines of the paragraph will be at least /// `(height + leading) * fontSize` tall when `fontSize` is not null. Omitting /// `height` (or setting it to [kTextHeightNone]) will allow the minimum line /// height to take the height as defined by the font, which may not be exactly /// the height of the `fontSize`. When `fontSize` is null, there is no minimum /// line height. Tall glyphs due to baseline alignment or large /// [TextStyle.fontSize] may cause the actual line height after layout to be /// taller than specified here. The `fontSize` must be provided for /// this property to take effect. /// /// * `leading`: The minimum amount of leading between lines as a multiple of /// the font size. `fontSize` must be provided for this property to take /// effect. The leading added by this property is distributed evenly over /// and under the text, regardless of `leadingDistribution`. /// /// * `leadingDistribution`: how the extra vertical space added by the /// `height` multiplier should be distributed over and under the text, /// independent of `leading` (which is always distributed evenly over and /// under text). Defaults to the paragraph's [TextHeightBehavior]'s leading /// distribution. /// /// * `fontWeight`: The typeface thickness to use when painting the text /// (e.g., bold). /// /// * `fontStyle`: The typeface variant to use when drawing the letters (e.g., /// italics). /// /// * `forceStrutHeight`: When true, the paragraph will force all lines to be exactly /// `(height + leading) * fontSize` tall from baseline to baseline. /// [TextStyle] is no longer able to influence the line height, and any tall /// glyphs may overlap with lines above. If a `fontFamily` is specified, the /// total ascent of the first line will be the min of the `Ascent + half-leading` /// of the `fontFamily` and `(height + leading) * fontSize`. Otherwise, it /// will be determined by the Ascent + half-leading of the first text. ``` ``````,aa+a4a@aMa\ahava}aaaabaaaab b+b=bRbfbbbbbbbbbc ccOc]cl'cc3cc0ce}feeddd d(ddyEyt/// A rectangle enclosing a run of text. /// /// This is similar to [Rect] but includes an inherent [TextDirection].ỳzzz!;/// Creates an object that describes a box containing text.z' z-z6z<zD zJzT zZzezkz}{'/// The left edge of the text box, irrespective of direction. /// /// To get the leading edge (which may depend on the [direction]), consider [start].{04{a!/// The top edge of the text box.{i|/// The right edge of the text box, irrespective of direction. /// /// To get the trailing edge (which may depend on the [direction]), consider [end].|:|Q$/// The bottom edge of the text box.|\V|6/// The direction in which text inside this box flows.}'}/// The [left] edge of the box for left-to-right text; the [right] edge of the box for right-to-left text. /// /// See also: /// /// * [direction], which specifies the text direction.~@/// The [right] edge of the box for left-to-right text; the [left] edge of the box for right-to-left text. /// /// See also: /// /// * [direction], which specifies the text direction.Q|l|0/// Returns a rect of the same size as this box.Wrqt |WX"5"#F>/// A position in a string of text. /// /// A TextPosition can be used to describe a caret position in between /// characters. The [offset] points to the position between `offset - 1` and /// `offset` characters of the string, and the [affinity] is used to describe /// which character this position affiliates with. /// /// One use case is when rendered text is forced to wrap. In this case, the offset /// where the wrap occurs could visually appear either at the end of the first /// line or the beginning of the second line. The second way is with /// bidirectional text. An offset at the interface between two different text /// directions could have one of two locations in the rendered text. /// /// See the documentation for [TextAffinity] for more information on how /// TextAffinity disambiguates situations like these.=I/// Creates an object representing a particular position in a string. /// /// The arguments must not be null (so the [offset] argument is required).P_j'pz<ҁ/// The index of the character that immediately follows the position in the /// string representation of the text. /// /// For example, given the string `'Hello'`, offset 0 represents the cursor /// being before the `H`, while offset 5 represents the cursor being just /// after the `o`.݁/// Disambiguates cases where the position in the string given by [offset] /// could represent two different visual positions in the rendered text. For /// example, this can happen when text is forced to wrap, or when one string /// of text is rendered with multiple text directions. /// /// See the documentation for [TextAffinity] for more information on how /// TextAffinity disambiguates situations like these.> d8:m./// A range of characters in a string of text.{ u/// Creates a text range. /// /// The [start] and [end] arguments must not be null. Both the [start] and /// [end] must either be greater than or equal to zero or both exactly -1. /// /// The text included in the range includes the character at [start], but not /// the one at [end]. /// /// Instead of creating an empty text range, consider using the [empty] /// constant.*4CNT`[U^_jpzuqxy /// A text range that starts and ends at offset. /// /// The [offset] argument must be non-null and greater than or equal to -1.! & 5;HC<FGYS[okq|}>/// A text range that contains nothing and is not in the text. u/// The index of the first character in the range. /// /// If [start] and [end] are both -1, the text range is empty.y/// The next index after the characters in this range. /// /// If [start] and [end] are both -1, the text range is empty. mk?/// Whether this range represents a valid position in the text.wO/// Whether this range is empty (but still potentially placed inside the text). ^M5/// Whether the start of this range precedes the end.Wn/// The text before this range. ~/// The text after this range.) 1y/// The text inside this range. ! ))G<)*tl/// Layout constraints for [Paragraph] objects. /// /// Instances of this class are typically used with [Paragraph.layout]. /// /// The only constraint that can be specified is the [width]. See the discussion /// at [width] for more details.b/// Creates constraints for laying out a paragraph. /// /// The [width] argument must not be null.- /// The width the paragraph should use whey computing the positions of glyphs. /// /// If possible, the paragraph will select a soft line break prior to reaching /// this width. If no soft line break is available, the paragraph will select /// a hard line break prior to reaching this width. If that would force a line /// break without any characters having been placed (i.e. if the next /// character to be laid out does not fit within the given width constraint) /// then the next character is allowed to overflow the width constraint and a /// forced line break is placed after it (even if an explicit line break /// follows). /// /// The width influences how ellipses are applied. See the discussion at /// [ParagraphStyle.new] for more details. /// /// This width is also used to position glyphs according to the [TextAlign] /// alignment described in the [ParagraphStyle] used when building the /// [Paragraph] with a [ParagraphBuilder]./14 <G!꒩/// [LineMetrics] stores the measurements and statistics of a single line in the /// paragraph. /// /// The measurements here are for the line as a whole, and represent the maximum /// extent of the line instead of per-run or per-glyph metrics. For more detailed /// metrics, see [TextBox] and [Paragraph.getBoxesForRange]. /// /// [LineMetrics] should be obtained directly from the [Paragraph.computeLineMetrics] /// method.QB/// Creates a [LineMetrics] object with only the specified values. -8GSbu   & ,7 =IOb hs y   Ew/// True if this line ends with an explicit line break (e.g. '\n') or is the end /// of the paragraph. False otherwise.SK%/// The rise from the [baseline] as calculated from the font and style for this line. /// /// This is the final computed ascent and can be impacted by the strut, height, scaling, /// as well as outlying runs that are very tall. /// /// The [ascent] is provided as a positive value, even though it is typically defined /// in fonts as negative. This is to ensure the signage of operations with these /// metrics directly reflects the intended signage of the value. For example, /// the y coordinate of the top edge of the line is `baseline - ascent`.U4/// The drop from the [baseline] as calculated from the font and style for this line. /// /// This is the final computed ascent and can be impacted by the strut, height, scaling, /// as well as outlying runs that are very tall. /// /// The y coordinate of the bottom edge of the line is `baseline + descent`.m/// The rise from the [baseline] as calculated from the font and style for this line /// ignoring the [TextStyle.height]. /// /// The [unscaledAscent] is provided as a positive value, even though it is typically /// defined in fonts as negative. This is to ensure the signage of operations with /// these metrics directly reflects the intended signage of the value. /// Total height of the line from the top edge to the bottom edge. /// /// This is equivalent to `round(ascent + descent)`. This value is provided /// separately due to rounding causing sub-pixel differences from the unrounded /// values.sN/// Width of the line from the left edge of the leftmost glyph to the right /// edge of the rightmost glyph. /// /// This is not the same as the width of the pargraph. /// /// See also: /// /// * [Paragraph.width], the max width passed in during layout. /// * [Paragraph.longestLine], the width of the longest line in the paragraph. žj/// The x coordinate of left edge of the line. /// /// The right edge can be obtained with `left + width`.§Ç/// The y coordinate of the baseline for this line from the top of the paragraph. /// /// The bottom edge of the paragraph up to and including this line may be obtained /// through `baseline + descent`.ÔL/// The number of this line in the overall paragraph, with the first line being /// index zero. /// /// For example, the first line is line 0, second line is line 1.FZFG[ux Ā[\́ȕ ځ5/// A paragraph of text. /// /// A paragraph retains the size and position of each glyph in the text and can /// be efficiently resized and painted. /// /// To create a [Paragraph] object, use a [ParagraphBuilder]. /// /// Paragraphs can be displayed on a [Canvas] using the [Canvas.drawParagraph] /// method. 耆hn/// The amount of horizontal space this paragraph occupies. /// /// Valid only after [layout] has been called.rl/// The amount of vertical space this paragraph occupies. /// /// Valid only after [layout] has been called.˺/// The distance from the left edge of the leftmost glyph to the right edge of /// the rightmost glyph in the paragraph. /// /// Valid only after [layout] has been called.ʀ|/// The minimum width that this paragraph could be without failing to paint /// its contents within itself. /// /// Valid only after [layout] has been called.̒9/// Returns the smallest width beyond which increasing the width never /// decreases the height. /// /// Valid only after [layout] has been called.Os/// The distance from the top of the paragraph to the alphabetic /// baseline of the first line, in logical pixels.逘mt/// The distance from the top of the paragraph to the ideographic /// baseline of the first line, in logical pixels.΅Z/// True if there is more vertical content, but the text was truncated, either /// because we reached `maxLines` lines of text or because the `maxLines` was /// null, `ellipsis` was not null, and one of the lines exceeded the width /// constraint. /// /// See the discussion of the `maxLines` and `ellipsis` arguments at /// [ParagraphStyle.new]. Ҁ/// The total number of visible lines in the paragraph. /// /// Returns a non-negative number. If `maxLines` is non-null, the value of /// [numberOfLines] never exceeds `maxLines`.؀摀/// Whether this reference to the underlying picture is [dispose]d. /// /// This only returns a valid value if asserts are enabled, and must not be /// used otherwise.  Ъ/// Computes the size and position of each glyph in the paragraph. /// /// The [ParagraphConstraints] control how wide the text is allowed to be.б ׃@Ӈ/// Returns a list of text boxes that enclose the given text range. /// /// The [boxHeightStyle] and [boxWidthStyle] parameters allow customization /// of how the boxes are bound vertically and horizontally. Both style /// parameters default to the tight option, which will provide close-fitting /// boxes and will not account for any line spacing. /// /// Coordinates of the TextBox are relative to the upper-left corner of the paragraph, /// where positive y values indicate down. /// /// The [boxHeightStyle] and [boxWidthStyle] parameters must not be null. /// /// See [BoxHeightStyle] and [BoxWidthStyle] for full descriptions of each option.Ә ӝӣӨӭ4ӽ1ՁI/// Returns a list of text boxes that enclose all placeholders in the paragraph. /// /// The order of the boxes are in the same order as passed in through /// [ParagraphBuilder.addPlaceholder]. /// /// Coordinates of the [TextBox] are relative to the upper-left corner of the paragraph, /// where positive y values indicate down.՟ז/// Returns the text position closest to the given offset. /// /// This method always returns a [TextPosition] for any given [offset], even /// when the [offset] is not close to any text, or when the paragraph is empty. /// This is useful for determining the text to select when the user drags the /// text selection handle. /// /// See also: /// /// * [getClosestGlyphInfoForOffset], which returns more information about /// the closest character to an [Offset].׫ ׳׾$N/// Returns the [GlyphInfo] of the glyph closest to the given `offset` in the /// paragraph coordinate system, or null if if the text is empty, or is /// entirely clipped or ellipsized away. /// /// This method first finds the line closest to `offset.dy`, and then returns /// the [GlyphInfo] of the closest glyph(s) within that line.A IT/// Returns the [GlyphInfo] located at the given UTF-16 `codeUnitOffset` in /// the paragraph, or null if the given `codeUnitOffset` is out of the visible /// lines or is ellipsized.+0CC_/// Returns the [TextRange] of the word at the given [TextPosition]. /// /// Characters not part of a word, such as spaces, symbols, and punctuation, /// have word breaks on both sides. In such cases, this method will return /// (offset, offset+1). Word boundaries are defined more precisely in Unicode /// Standard Annex #29 http://www.unicode.org/reports/tr29/#Word_Boundaries /// /// The [TextPosition] is treated as caret position, its [TextPosition.affinity] /// is used to determine which character this position points to. For example, /// the word boundary at `TextPosition(offset: 5, affinity: TextPosition.upstream)` /// of the `string = 'Hello word'` will return range (0, 5) because the position /// points to the character 'o' instead of the space.o}݊[޾/// Returns the [TextRange] of the line at the given [TextPosition]. /// /// The newline (if any) is returned as part of the range. /// /// Not valid until after layout. /// /// This can potentially be expensive, since it needs to compute the line /// metrics, so use it sparingly.[/%/// Returns the full list of [LineMetrics] that describe in detail the various /// metrics of each laid out line. /// /// Not valid until after layout. /// /// This can potentially return a large amount of data, so it is not recommended /// to repeatedly call this. Instead, cache the results.H耎/// Returns the [LineMetrics] for the line at `lineNumber`, or null if the /// given `lineNumber` is greater than or equal to [numberOfLines].j*$/// Returns the line number of the line that contains the code unit that /// `codeUnitOffset` points to. /// /// This method returns null if the given `codeUnitOffset` is out of bounds, or /// is logically after the last visible codepoint. This includes the case where /// its codepoint belongs to a visible line, but the text layout library /// replaced it with an ellipsis. /// /// If the target code unit points to a control character that introduces /// mandatory line breaks (most notably the line feed character `LF`, typically /// represented in strings as the escape sequence "\n"), to conform to /// [the unicode rules](https://unicode.org/reports/tr14/#LB4), the control /// character itself is always considered to be at the end of "current" line /// rather than the beginning of the new line.:?Rn/// Release the resources used by this object. The object is no longer usable /// after this method is called.棢p緀/// This class is created by the engine, and should not be instantiated /// or extended directly. /// /// To create a [Paragraph] object, use a [ParagraphBuilder].JO[ zO   71+3Y|YZefltm|}ـS    ; 5/7ccdopv~wy + *$)%,a3-5[U]ꏀ''(34:YB;JXKRWSZa[c='!#4|45@AGfOHWeX_d`gnhpezefSdk STgo w* ) #+U2,4OIQ큁Uo 41UV0B GMRV[jordK%' l   lms{tj+:?􁀭 "2If n23<Z be mpz$< <=CjKDSiT[`\ckrltȃ  QXgnvx#"  $?+%-~j->C $[[\bicqry~z怍w;k/// This can't be a leaf call because the native function calls Dart API /// (Dart_SetNativeInstanceField).    ) cvcd  q/// Builds a [Paragraph] containing text with the given styling information. /// /// To set the paragraph's alignment, truncation, and ellipsizing behavior, pass /// an appropriately-configured [ParagraphStyle] object to the /// [ParagraphBuilder.new] constructor. /// /// Then, call combinations of [pushStyle], [addText], and [pop] to add styled /// text to the object. /// /// Finally, call [build] to obtain the constructed [Paragraph] object. After /// this point, the builder is no longer usable. /// /// After constructing a [Paragraph], call [Paragraph.layout] on it and then /// paint it with [Canvas.drawParagraph].   W/// Creates a new [ParagraphBuilder] object, which is used to create a /// [Paragraph].  0 TV :/// The number of placeholders currently in the paragraph. Z 4/// The scales of the placeholders in the paragraph.  {c/// Applies the given style to the added text until [pop] is called. /// /// See [pop] for details.   Q9/// Ends the effect of the most recent call to [pushStyle]. /// /// Internally, the paragraph builder maintains a stack of text styles. Text /// added to the paragraph is affected by all the styles in the stack. Calling /// [pop] removes the topmost style in the stack, leaving the remaining styles /// in effect.sx/// Adds the given text to the paragraph. /// /// The text will be styled according to the current stack of text styles.{ /// Adds an inline placeholder space to the paragraph. /// /// The paragraph will contain a rectangular space with no text of the dimensions /// specified. /// /// The `width` and `height` parameters specify the size of the placeholder rectangle. /// /// The `alignment` parameter specifies how the placeholder rectangle will be vertically /// aligned with the surrounding text. When [PlaceholderAlignment.baseline], /// [PlaceholderAlignment.aboveBaseline], and [PlaceholderAlignment.belowBaseline] /// alignment modes are used, the baseline needs to be set with the `baseline`. /// When using [PlaceholderAlignment.baseline], `baselineOffset` indicates the distance /// of the baseline down from the top of the rectangle. The default `baselineOffset` /// is the `height`. /// /// Examples: /// /// * For a 30x50 placeholder with the bottom edge aligned with the bottom of the text, use: /// `addPlaceholder(30, 50, PlaceholderAlignment.bottom);` /// * For a 30x50 placeholder that is vertically centered around the text, use: /// `addPlaceholder(30, 50, PlaceholderAlignment.middle);`. /// * For a 30x50 placeholder that sits completely on top of the alphabetic baseline, use: /// `addPlaceholder(30, 50, PlaceholderAlignment.aboveBaseline, baseline: TextBaseline.alphabetic)`. /// * For a 30x50 placeholder with 40 pixels above and 10 pixels below the alphabetic baseline, use: /// `addPlaceholder(30, 50, PlaceholderAlignment.baseline, baseline: TextBaseline.alphabetic, baselineOffset: 40)`. /// /// Lines are permitted to break around each placeholder. /// /// Decorations will be drawn based on the font defined in the most recently /// pushed [TextStyle]. The decorations are drawn as if unicode text were present /// in the placeholder space, and will draw the same regardless of the height and /// alignment of the placeholder. To hide or manually adjust decorations to fit, /// a text style with the desired decoration behavior should be pushed before /// adding a placeholder. /// /// Any decorations drawn through a placeholder will exist on the same canvas/layer /// as the text. This means any content drawn on top of the space reserved by /// the placeholder will be drawn over the decoration, possibly obscuring the /// decoration. /// /// Placeholders are represented by a unicode 0xFFFC "object replacement character" /// in the text buffer. For each placeholder, one object replacement character is /// added on to the text buffer. /// /// The `scale` parameter will scale the `width` and `height` by the specified amount, /// and keep track of the scale. The scales of placeholders added can be accessed /// through [placeholderScales]. This is primarily used for accessibility scaling.   *!/// Applies the given paragraph style and returns a [Paragraph] containing the /// added text and associated styling. /// /// After calling this function, the paragraph builder object is invalid and /// cannot be used further.-A8###&#t2#######9#":"""#,E#I#,#- !]p!""""("8"@"Q"a"w"" """" "!]!^!d!!j!e!r!!s!{!!!!!!!!!!!!#鈯#$$##,5..).4.@.O.`.h.u.}... .... .. .///1 /A/W/b/u///// ,,,-,,,-,,,,,,---%-7-I-[-m-------.---/H///0!w00!0"0-0.040Q0:050B0P0C0J0O0K0R00Y0S0[0z0t0|000 00016~11 116171=1d1E1>1M1c1N1U1Z1V1]1e11l1f1n1q11 11 112 22#232<2O2^112*5-55 55 55 5556 65-5.545y5:555B5x5C5J5O5K5R5Z5b5j5r5z555{5662666777'6666666666666666667847K7879 ڂ-M/// Whether to use the italic type variation of glyphs in the font. /// /// Some modern fonts allow this to be selected in a more fine-grained manner. /// See [FontVariation.italic] for details. /// /// Italic type is distinct from slanted glyphs. To control the slant of a /// glyph, consider the [FontVariation.slant] font feature.;.c%/// Use the upright ("Roman") glyphs.nnc/// Use glyphs that have a more pronounced angle and typically a cursive style /// ("italic type").q //// Whether and how to align text horizontally.<Q5/// Align the text on the left edge of the container.Z>̓6/// Align the text on the right edge of the container.̝;2/// Align the text in the center of the container.͚݀/// Stretch lines of text that end with a soft line break to fill the width of /// the container. /// /// Lines that end with hard line breaks are aligned towards the [start] edge.ͦ΄/// Align the text on the leading edge of the container. /// /// For left-to-right text ([TextDirection.ltr]), this is the left edge. /// /// For right-to-left text ([TextDirection.rtl]), this is the right edge.Ύm/// Align the text on the trailing edge of the container. /// /// For left-to-right text ([TextDirection.ltr]), this is the right edge. /// /// For right-to-left text ([TextDirection.rtl]), this is the left edge.uϨ-/// A horizontal line used for aligning text.ϹbU/// The horizontal line used to align the bottom of glyphs for alphabetic characters. K`=/// The horizontal line used to align ideographic characters.4j0/// The style in which to draw a text decorationׂך/// Draw a solid lineפ׹/// Draw two lines/// Draw a dotted line/// Draw a dashed line !)/// Draw a sinusoidal line1c,/// {@macro dart.ui.textLeadingDistribution}G/// Distributes the [leading](https://en.wikipedia.org/wiki/Leading) /// of the text proportionally above and below the text, to the font's /// ascent/descent ratio. /// /// {@template dart.ui.leading} /// The leading of a text run is defined as /// `TextStyle.height * TextStyle.fontSize - TextStyle.fontSize`. When /// [TextStyle.height] is not set, the text run uses the leading specified by /// the font instead. /// {@endtemplate}X'/// Distributes the ["leading"](https://en.wikipedia.org/wiki/Leading) /// of the text evenly above and below the text (i.e. evenly above the /// font's ascender and below the descender). /// /// {@macro dart.ui.leading} /// /// The leading can become negative when [TextStyle.height] is smaller than /// 1.0. /// /// This is the default strategy used by CSS, known as /// ["half-leading"](https://www.w3.org/TR/css-inline-3/#half-leading).fqx/// A direction in which text flows. /// /// Some languages are written from the left to the right (for example, English, /// Tamil, or Chinese), while others are written from the right to the left (for /// example Aramaic, Hebrew, or Urdu). Some are also written in a mixture, for /// example Arabic is mostly written right-to-left, with numerals written /// left-to-right. /// /// The text direction must be provided to APIs that render text or lay out /// boxes horizontally, so that they can determine which direction to start in: /// either right-to-left, [TextDirection.rtl]; or left-to-right, /// [TextDirection.ltr]. /// /// ## Design discussion /// /// Flutter is designed to address the needs of applications written in any of /// the world's currently-used languages, whether they use a right-to-left or /// left-to-right writing direction. Flutter does not support other writing /// modes, such as vertical text or boustrophedon text, as these are rarely used /// in computer programs. /// /// It is common when developing user interface frameworks to pick a default /// text direction — typically left-to-right, the direction most familiar to the /// engineers working on the framework — because this simplifies the development /// of applications on the platform. Unfortunately, this frequently results in /// the platform having unexpected left-to-right biases or assumptions, as /// engineers will typically miss places where they need to support /// right-to-left text. This then results in bugs that only manifest in /// right-to-left environments. /// /// In an effort to minimize the extent to which Flutter experiences this /// category of issues, the lowest levels of the Flutter framework do not have a /// default text reading direction. Any time a reading direction is necessary, /// for example when text is to be displayed, or when a /// writing-direction-dependent value is to be interpreted, the reading /// direction must be explicitly specified. Where possible, such as in `switch` /// statements, the right-to-left case is listed first, to avoid the impression /// that it is an afterthought. /// /// At the higher levels (specifically starting at the widgets library), an /// ambient [Directionality] is introduced, which provides a default. Thus, for /// instance, a [widgets.Text] widget in the scope of a [MaterialApp] widget /// does not need to be given an explicit writing direction. The /// [Directionality.of] static method can be used to obtain the ambient text /// direction for a particular [BuildContext]. /// /// ### Known left-to-right biases in Flutter /// /// Despite the design intent described above, certain left-to-right biases have /// nonetheless crept into Flutter's design. These include: /// /// * The [Canvas] origin is at the top left, and the x-axis increases in a /// left-to-right direction. /// /// * The default localization in the widgets and material libraries is /// American English, which is left-to-right. /// /// ### Visual properties vs directional properties /// /// Many classes in the Flutter framework are offered in two versions, a /// visually-oriented variant, and a text-direction-dependent variant. For /// example, [EdgeInsets] is described in terms of top, left, right, and bottom, /// while [EdgeInsetsDirectional] is described in terms of top, start, end, and /// bottom, where start and end correspond to right and left in right-to-left /// text and left and right in left-to-right text. /// /// There are distinct use cases for each of these variants. /// /// Text-direction-dependent variants are useful when developing user interfaces /// that should "flip" with the text direction. For example, a paragraph of text /// in English will typically be left-aligned and a quote will be indented from /// the left, while in Arabic it will be right-aligned and indented from the /// right. Both of these cases are described by the direction-dependent /// [TextAlign.start] and [EdgeInsetsDirectional.start]. /// /// In contrast, the visual variants are useful when the text direction is known /// and not affected by the reading direction. For example, an application /// giving driving directions might show a "turn left" arrow on the left and a /// "turn right" arrow on the right — and would do so whether the application /// was localized to French (left-to-right) or Hebrew (right-to-left). /// /// In practice, it is also expected that many developers will only be /// targeting one language, and in that case it may be simpler to think in /// visual terms.xBx/// The text flows from left to right (e.g., English, French).ىk/// A way to disambiguate a [TextPosition] when its offset could match two /// different locations in the rendered string. /// /// For example, at an offset where the rendered text wraps, there are two /// visual positions that the offset could represent: one prior to the line /// break (at the end of the first line) and one after the line break (at the /// start of the second line). A text affinity disambiguates between these two /// cases. /// /// This affects only line breaks caused by wrapping, not explicit newline /// characters. For newline characters, the position is fully specified by the /// offset alone, and there is no ambiguity. /// /// [TextAffinity] also affects bidirectional text at the interface between LTR /// and RTL text. Consider the following string, where the lowercase letters /// will be displayed as LTR and the uppercase letters RTL: "helloHELLO". When /// rendered, the string would appear visually as "helloOLLEH". An offset of 5 /// would be ambiguous without a corresponding [TextAffinity]. Looking at the /// string in code, the offset represents the position just after the "o" and /// just before the "H". When rendered, this offset could be either in the /// middle of the string to the right of the "o" or at the end of the string to /// the right of the "H". /// The position has affinity for the upstream side of the text position, i.e. /// in the direction of the beginning of the string. /// /// In the example of an offset at the place where text is wrapping, upstream /// indicates the end of the first line. /// /// In the bidirectional text example "helloHELLO", an offset of 5 with /// [TextAffinity] upstream would appear in the middle of the rendered text, /// just to the right of the "o". See the definition of [TextAffinity] for the /// full example.&7/// The position has affinity for the downstream side of the text position, /// i.e. in the direction of the end of the string. /// /// In the example of an offset at the place where text is wrapping, /// downstream indicates the beginning of the second line. /// /// In the bidirectional text example "helloHELLO", an offset of 5 with /// [TextAffinity] downstream would appear at the end of the rendered text, /// just to the right of the "H". See the definition of [TextAffinity] for the /// full example.Y/// Defines various ways to vertically bound the boxes returned by /// [Paragraph.getBoxesForRange]. /// /// See [BoxWidthStyle] for a similar property to control width./// Provide tight bounding boxes that fit heights per run. This style may result /// in uneven bounding boxes that do not nicely connect with adjacent boxes.ǁ/// The height of the boxes will be the maximum height of all runs in the /// line. All boxes in the same line will be the same height. /// /// This does not guarantee that the boxes will cover the entire vertical height of the line /// when there is additional line spacing. /// /// See [BoxHeightStyle.includeLineSpacingTop], [BoxHeightStyle.includeLineSpacingMiddle], /// and [BoxHeightStyle.includeLineSpacingBottom] for styles that will cover /// the entire line.rA/// Extends the top and bottom edge of the bounds to fully cover any line /// spacing. /// /// The top and bottom of each box will cover half of the /// space above and half of the space below the line. /// /// {@template dart.ui.boxHeightStyle.includeLineSpacing} /// The top edge of each line should be the same as the bottom edge /// of the line above. There should be no gaps in vertical coverage given any /// amount of line spacing. Line spacing is not included above the first line /// and below the last line due to no additional space present there. /// {@endtemplate}-/// Extends the top edge of the bounds to fully cover any line spacing. /// /// The line spacing will be added to the top of the box. /// /// {@macro dart.ui.boxHeightStyle.includeLineSpacing}/// Extends the bottom edge of the bounds to fully cover any line spacing. /// /// The line spacing will be added to the bottom of the box. /// /// {@macro dart.ui.boxHeightStyle.includeLineSpacing}XSF/// Calculate box heights based on the metrics of this paragraph's [StrutStyle]. /// /// Boxes based on the strut will have consistent heights throughout the /// entire paragraph. The top edge of each line will align with the bottom /// edge of the previous line. It is possible for glyphs to extend outside /// these boxes.]/// Defines various ways to horizontally bound the boxes returned by /// [Paragraph.getBoxesForRange]. /// /// See [BoxHeightStyle] for a similar property to control height."f\/// Provide tight bounding boxes that fit widths to the runs of each line /// independently.{i/// Adds up to two additional boxes as needed at the beginning and/or end /// of each line so that the widths of the boxes in line are the same width /// as the widest line in the paragraph. /// /// The additional boxes on each line are only added when the relevant box /// at the relevant edge of that line does not span the maximum width of /// the paragraph. /// Where to vertically align the placeholder relative to the surrounding text. /// /// Used by [ParagraphBuilder.addPlaceholder].X/// Match the baseline of the placeholder with the baseline. /// /// The [TextBaseline] to use must be specified and non-null when using this /// alignment mode.eN/// Align the bottom edge of the placeholder with the baseline such that the /// placeholder sits on top of the baseline. /// /// The [TextBaseline] to use must be specified and non-null when using this /// alignment mode.`M/// Align the top edge of the placeholder with the baseline specified /// such that the placeholder hangs below the baseline. /// /// The [TextBaseline] to use must be specified and non-null when using this /// alignment mode._1/// Align the top edge of the placeholder with the top edge of the text. /// /// When the placeholder is very tall, the extra space will hang from /// the top and extend through the bottom of the line.9/// Align the bottom edge of the placeholder with the bottom edge of the text. /// /// When the placeholder is very tall, the extra space will rise from the /// bottom and extend through the top of the line.߀/// Align the middle of the placeholder with the middle of the text. /// /// When the placeholder is very tall, the extra space will grow equally /// from the top and bottom of the line. /// Determines if lists [a] and [b] are deep equivalent. /// /// Returns true if the lists are both null, or if they are both non-null, have /// the same length, and contain the same elements in the same order. Returns /// false otherwise. &( 2(< DL]jr$ $1 @U^ir##9)) **$*0*@*P *V*a*j*w****&******++++'+0N=NF NVN_Nl N{NNNNN,NNNNOOOO+O27p(8,/// Loads a font from a buffer and makes it available for rendering text. /// /// * `list`: A list of bytes containing the font file. /// * `fontFamily`: The family name used to identify the font in text styles. /// If this is not provided, then the family name will be extracted from the font file.8888:$:*gh΋ϋ,ejk M6TZ<֐&sDdʑݑAEFRhܒ0Lh/q7x|ϕӖ#.2@Dǖ˗J^8yșTZәB"#uAY^-t6^(mFV\06FL$*i6tzƥ_VΧԨAG\,mWioѫVͫӬ^ڬ'nȮOٯbҰu{ f0p̳ #8G̵"(m hnҶK1Ib׸ݹgDJ $4:ѻҼ LҼBlrɾ ?io;ӿ/AGW]@ @K@L@q@w@AAOAoAuABBB\BbBwBCC3C9CCDDDD.D4DDDDDEGEEEEF#F)FjFFG<GGH HLHHIIIQIWIlIIJ:JyJJJK2KsKKKL_LeLLLLLMPMMMMN NPNNOObO}OOOOP)PcPiPPQ.Q@QFQVQ\QQQR!R'RdRRS4SzSST0T6TzTUUHUUVVV$VTVVVVW WYWWXEXKXXYY Y&Y6Y<YYZZhZiZZ[#[b[h[[\/\5\J\\\\]9]~]]]^^ ^i^o^^^^__V____`)`p```aaJaPaabb#b)b9b?bbbbccIccdd_dkdqdddde4e_eeeef,f>fDfTfZffg+g,gdgjggh1h7hvh|hhiiirixiiijjj\jjjjk+kXk^kkkkkl?llm mMmtmzmmnEnWn]nmnsnoooNoToopGpgpmpppqqqqnqqqqrr\rrrs$s*s?ssttJttttuBuHuuuuuvDvvvw wwZwwxx x_xexzxxxyJyPyyyyyz;zzzz{{D{J{{{{||X||}}_}}}}~~"~~~~S]c);AQW9i^d*0ExW9? N`f.4I kqT P:xT!' g(. Z`8z8>$hi KQfFL!'7=#BCbz{J8Y_ou%m /[ou+egh>BSWc`GK8hn>DEH'-u{llm?E6B/MSPScnohz<=bh&swxNcd,"scO-O.4Vtg(yB'w]}"(BQ¨¯³´Eim{>āę9:ŮSƛƜVǦ23sȣȤ 0Rekɉ#Z^_knpqˡOWX̛̑̚,AGͣͤ͘06΂΋Ό krtuϣϷ^mopПж,qуѾ  ~Ҧ12aӢӣ :}~Ԋԭ()5KaՅՋշ+IOy֚֠־-134e׀טסע׷ '.01^} )/Q0EUVڟ=Cۑۜۢ%-/0[ܜܠnݹDy,-\b߰'u9HNSYZ-d `[a9?17+{?~ OmFZ`PTUav>QU6I_c')*vyA*-{;>wz:Jh/Sg!HLu &?ae+/Kd>Bg"<Vz~:>Vp(LPl 'Aei04BFk g7_T1l  W   Z h z      7 W o      % 9 P g     =      >Sg~(=Of1X{"=b *Ha"PNz&dO59:F[;Wj<XP$(<   !!"3"#G#l#$E$%Y%&m&'' ' ' 'Q'T'''((Z(((((()+).)b)e))))**.*N*_*u*****++%+7+;+++++,,,>,B,^,w,,,,,,--)-C-G-k-----...-.F.j.n.//=/V/z/~/////004080P0j0000001,1C1n1t12 2Z22233[33347445(5d556 6P6V6667A778$8v8889)9/9~9: ::Z:p:v:::;1;};;; >>T>g>>>>>>?$?@?Z?v?????@@@0@A@^@s@@@@@@AA!ABA_AxAABB!B<BUBvBBBBBCC2CECKCwCCCCDD,DXDDDEEEE*EEEEEFgFGQGH;H`HI+IJJJKtKKKKKLFLLM7MMMNN=NTNjNNNNNOO)OEOOP)PEP]PwPPPPQQQ Q!Q_QQQQQR RR*RARoRRRRSS"S#SeSfSSSSSTTTWTkToTTTTTUU,U0U1UMUNUiUUUUUUVlVpVVVWWWWgWWXXXXiXXYMYYZ7ZZZZ[L[[\(\.\w\]]`]v]|]]]^4^F^L^^_=__`3`~`````a'a<aXaraaaaabb"b4bIb]bxbbbcccMcjcccddd d0dRdedkddddde:eeeeefmfnfpfqfffg<ggggh8hhhhhiiRiij=jWj[jjkJkkl(lplllm/m~mmnNnnnoo^oop9phplpppq+q/q|qqqrrrRrVrrs;sst ttMtQttuCuuvvvfvwwNwwwx+x=xxxxxy;yByDyEynyryyzz#z2z@zPzazuzzz{zz{{-{.{R{f{g{{||||B|Y|Z||||}$}%}}}}}}~9~=~>~~~~PTUa!?[{ ,$TX=5bfS@ [c#$r28!5CEFjnP)nO5Lfe(wP>`1578gy5;0Gc}~-Kcyz17x `  Bkl8Rrvw1Sfl!&'3qstEf $*+|#t [4:!Dp  VXYlQWFQa*+u{]cQW>QZ\]  l%PV   ]a@Vbc6L]^5K\]/67ag;JN.24Oq"3E^o8PQ =C>ZRy,u.V\lrOU¤¥TxÑÒ@XYeĈĴ8\ŎŰ?CDPIvDZ,[ȎȒȔȕȮȲ*.lpɿ$*[opʬʲJv|˭8>ȍ̐,LM͐+`΂΃$qσω  PVУ!oѸ>Dҝ"wlrԺDq՜՝/ց Xׇ׻׼ V؁؇QR٠@Aڈڎ*z!rS݈݇<Bގ޲8]c߇ߍEF  EK-OUDhn U#OP"pA]c9VWc=`amc$%1)PQ]W~%Z},6<NRS_hlm~M eij/0<& -^59:I8 Z:'(xA3hDs/fpw12>&UY+CV`ptu+GHbco\`am 2Zbu     b f    " q      ]     Q R       Q W t    +|l.4=>'dQ,'w?Qtz'|!'(y*,-'_ N| Iz  ! C K _ w    !!'!M!V!Z![!!""2"K"q"""""""# #)#*#6#r#####$$M$z$$%%!%"%P%%&7&8&&&&''A'a''( (u((((()!)C)))*i********++>+X++++, ,),V,q,,,,,,,,,- ----?-Q-c-u-----. .%.<.\.q.....//-/S/q/////000+00000011)1/1314111122/2K2g2n223<33414`455&5*5+5666&6<6y6666675767B7m7o7p7778D88899S9f9l9999::::K::;;7;q;;;;;<:<><@