9 _formatter_parent_source_chunks_pendingNewlines _pendingSpace_pendingNested_pendingFlushLeft _afterComment_rules_hardSplitRules _lazyRules _openSpans_nesting_blockArgumentNesting_preventSplitNesting pageWidthrulewrite writeNewline writeSpacesplit writeComments_writeCommentTextindentunindent startSpanendSpan startRule _activateRule startLazyRuleendRule forceRulesnestExpressionunneststartSelectionFromEndendSelectionFromEndstartBlockArgumentNestingendBlockArgumentNesting startBlockendBlockend preventSplitendPreventSplit_emitPendingWhitespace_chunkForComment_isGenericMethodComment_needsSpaceBeforeComment_needsSpaceAfterComment_needsBlankLineBeforeComment _writeSplit _writeText _startChunk _divideChunks _canDivide_handleHardSplit _hardenRules_trailingIdentifierChar_javaDocComment _javaDocLine_leadingIndentation ChunkBuilderrRegExp SourceVisitorChunk DartFormatter SourceCodeListintboolRuleOpenSpanNestingBuilder NestingLevel pageWidthlastindentmergeEmptySplitsvoidStringforEachclear commitNestingisDouble flushLeftnestspacedummyisHard SourceCommentfirst linesBeforeilengtheverycommenttype CommentType inlineBlock updateSplit isNotEmptyselectionStarttext selectionEndcontainsfixesStyleFix docCommentschunk firstMatchsplittoList trimRightminisEmptyremoveAt removeLastaddline substringspacesIndentblockunindentcostCostnormalstartSpanrule isHardenedspansoutersplitsOnInnerRulesconstrainWhenSplit expressionnowunneststartSelectionFromEndendSelectionFromEndcurrentNesting LineWriter BlockChunk argumentChunk indentation_childrenhard startRule forceSplitunsplitBlockLength forceRulestraceChunkBuilderloggreen dumpChunks writeLinesisCompilationUnituriselectionLength WhitespacedocendsWith startsWithhasMatchhardennesting appendText LineSplitter preventDivideindexisNestedconstrainedRulesother constrainfullySplitValue>FT{ math dart:math chunk.dart comment_type.dart'constants.dart@dart_formatter.dart^qtdebugt debug.dart|line_writer.dartnesting_builder.dartnesting_level.dartrule/rule.dartsource_code.dartsource_comment.dart%style_fix.dartzN؀ &?]{ҁ$=>‚Ã#deCD$(yÅ"#tdžȆGciRqrLjȉ$%`f܉݊)FL6~ʌ:;njȍ -.Glm56GǏ͏eՐ֑3RswxƑ/5ϓflr DJ-u•ߕ6,DEl—×:ՙ#m|ݚ)DHIL4|ќ 3OUV267 SYIޡ3IPho Q΢ݣ>ZmyӤk#*:N`g"HdjkSߧEf$*+f0K!p̫֫ClҭA^֭$./߯-56`H^İ8R]p&./Ka -pH 9`ntuյֶNuvط (DNVW7?@W]^[_`ûĻ1^ɼ;Y۾ *cimnܾ@nǿ˿̿@6@V@@@@@@AA>ADAAAAB.BSBhBiBBBBBBBCC"C(C,C-CxC~CDDiDDEE[EEEFF8F>FFGG8GKGLGgGGGGGH&H_HeHHHIIIIFIJIKIIIJ+JcJJJJJK5KmKsKKL%LELFLLLLMMGMMMQMRMMMNNNNlNNNNOOOROmOPPKP]PPQQQ:Q;QQQQQRKRrRRRRRRRSCSISST,TcTiTTTTU<UkUUUVV)V?VbVVVVWWWNWWX0XMX^XhXpXvXwXXYY:YMYQYRYYYYYZ Z Z0ZZZ~ZZZZZ[$[%[>[X[[[[\.\\\\\\\\] ]&]\]]]]]]]]^^$^`^d^e^^__7_V_____``8`e`i`j```aAabaaaab%bTbUbbccc!c"cscdd#dAd_dddde e;eeeeef3fQfofffffffg)g/gzgggh,h0h1hhhiifiiijjNjjjkk7k[k\kkkl l9lkllllm m$m%msmmnnLnMnynznnooooiooooopppp p]ppppq!q"qdqqqqqqrrr7rLrgrrrrrs@ssstKtgthtttuu6u@uHuIuuuvvvRvvvvvvwwwwwcw|wwwxxxx;xAxBxxxxxxxy;ynyoyyz z z+z=zAzBzzz{{N{g{{|||6|T|||||}}/}W}}}}}~~<~=~~~~ Vr12~BH Ar?IQWX&Ifntxz  &?]t{$  ,$./ؐ؀z   zzp%/// The builder for the code surrounding the block that this writer is for, or /// `null` if this is writing the top-level code.ۆ/// The number of newlines that should be written before the next /// non-whitespace token. /// /// This will always be 0, 1, or 2.eH/// Whether a non-breaking space should be written before the next text.jYWY9/// Whether the next chunk should use expression nesting.tQ0/// Whether the next chunk should be flush left. X ;/// Whether the most recently written output was a comment.؉ى҉׉Ӊɉ'ɀ/// The nested stack of rules that are currently in use. /// /// New chunks are implicitly split by the innermost rule when the chunk is /// ended.67051߂Y&/// The set of rules known to contain hard splits that will in turn force /// these rules to harden. /// /// This is accumulated lazily while chunks are being built. Then, once they /// are all done, the rules are all hardened. We do this later because some /// rules may not have all of their constraints fully wired up until after /// the hard split appears. For example, a hard split in a positional /// argument list needs to force the named arguments to split too, but we /// don't create that rule until after the positional arguments are done.ÌȌ=h/// The list of rules that are waiting until the next whitespace has been /// written before they start.)*( a?/// The nested stack of spans that are currently being written.ZhiO0:O/// The current state.12#0$ o /// The stack of nesting levels where block arguments may start. /// /// A block argument's contents will nest at the last level in this stack.8/// The number of calls to [preventSplit()] that have not been ended by a /// call to [endPreventSplit()]. /// /// Splitting is completely disabled inside string interpolation. We do want /// to fix the whitespace inside interpolation, though, so we still format /// them. This tracks whether we're inside an interpolation. We can't use a /// simple bool because interpolation can nest. /// /// When this is non-zero, splits are ignored.!!poC/// The number of characters of code that can fit in a single line.?/// The current innermost rule.' ˖/// Writes [string], the text for a single token, to the output. /// /// By default, this also implicitly adds one level of nesting if we aren't /// currently nested at all. We do this here so that if a comment appears /// after any token within a statement or top-level form and that comment /// leads to splitting, we correctly nest. Even pathological cases like: /// /// /// import // comment /// "this_gets_nested.dart"; /// /// If we didn't do this here, we'd have to call [nestExpression] after the /// first token of practically every grammar production. /// /// If [mergeEmptySplits] is `true`, the default, then any pending split /// information will be combined with a previously created split if no text /// has been written since. This generally comes into play when text is /// written after a comment. The comment may leave some pending split /// information while [SourceVisitor] may have also created a split and we /// want to combine those. /// /// It is only `false` when writing the contents of a multiline string. There, /// we may *want* to have a series of empty chunks because those represent /// empty lines in the multiline string.Ǚӗŗł/// Writes one or two hard newlines. /// /// Doesn't immediately write them. That way line breaking is correctly /// interleaved with any comments that appear before the next token. /// /// If [isDouble] is `true`, inserts an extra blank line. If [flushLeft] is /// `true`, the next line will start at column 1 and ignore indentation and /// nesting. If [nest] is `true` then the next line will use expression /// nesting.KKq=/// Writes a space before the subsequent non-whitespace text.ћ˛ޚu/// Write a split owned by the current innermost rule. /// /// If [nest] is `false`, ignores any current expression nesting. Otherwise, /// uses the current nesting level. If unsplit, it expands to a space if /// [space] is `true`.##'99 @99T/// Outputs the series of [comments] and associated whitespace that appear /// before [token] (which is not written by this). /// /// The list contains each comment as it appeared in the source between the /// last token written and the next one that's about to be written. /// /// [linesBeforeToken] is the number of lines between the last comment (or /// previous token if there are no comments) and the next token.-77 > p/// Writes the text of [comment]. /// /// If it's a JavaDoc comment that should be fixed to use `///`, fixes it... 3&/// Creates a new indentation level [spaces] deeper than the current one. /// /// If omitted, [spaces] defaults to [Indent.block].bb`//// Discards the most recent indentation level.CCGNRSƻƀ8f/// Starts a new span with [cost]. /// /// Each call to this needs a later matching call to [endSpan]./// Ends the innermost span.; ppZF/// Starts a new [Rule]. /// /// If omitted, defaults to a new [Rule]. ο΀BDBD BJ@@΁B5Q/// Starts a new [Rule] that comes into play *after* the next whitespace /// (including comments) is written. /// /// This is used for operators who want to start a rule before the first /// operand but not get forced to split if a comment appears before the /// entire expression. /// /// If [rule] is omitted, defaults to a new [Rule].BBB/// Ends the innermost rule.C/C/E^/// Pre-emptively forces all of the current rules to become hard splits. /// /// This is called by [SourceVisitor] when it can determine that a rule will /// will always be split. Turning it (and the surrounding rules) into hard /// splits lets the writer break the output into smaller pieces for the line /// splitter, which helps performance and avoids failing on very large input. /// /// In particular, it's easy for the visitor to know that collections with a /// large number of items must split. Doing that early avoids crashing the /// splitter when it tries to recurse on huge collection literals.GG G"G*G* G0EE΁G -/// Begins a new expression nesting level [indent] spaces deeper than the /// current one if it splits. /// /// If [indent] is omitted, defaults to [Indent.expression]. If [now] is /// `true`, commits the nesting change immediately instead of waiting until /// after the next chunk of text is written.HH HGGH߁6/// Discards the most recent level of expression nesting. /// /// Expressions that are more nested will get increased indentation when split /// if the previous line has a lower level of nesting. /// /// If [now] is `false`, does not commit the nesting change until after the /// next chunk of text is written.JJ JIMIMJj /// Marks the selection starting point as occurring [fromEnd] characters to /// the left of the end of what's currently been written. /// /// It counts backwards from the end because this is called *after* the chunk /// of text containing the selection has been output.LL LJJiL /// Marks the selection ending point as occurring [fromEnd] characters to the /// left of the end of what's currently been written. /// /// It counts backwards from the end because this is called *after* the chunk /// of text containing the selection has been output.MTMTMd/// Captures the current nesting level as marking where subsequent block /// arguments should start.NNNsL/// Releases the last nesting level captured by [startBlockArgumentNesting].OtOtO{OOOOOOOONN3Oa/// Starts a new block chunk and returns the [ChunkBuilder] for it. /// /// Nested blocks are handled using their own independent [LineWriter].TTTTRR[T/// Ends this [ChunkBuilder], which must have been created by [startBlock()]. /// /// Forces the chunk that owns the block to split if it can tell that the /// block contents will always split. It does that by looking for hard splits /// in the block that aren't for top level elements in the block. If /// [forceSplit] is `true`, the block always splits. /// /// Returns the previous writer for the surrounding block.YTYT^Yn/// Finishes writing and returns a [SourceCode] containing the final output /// and updated selection, if any.]]5]]]t]_]_]_b_t_t_y_m_^g^g_>/// Writes the current pending [Whitespace] to the output, if any. /// /// This should only be called after source lines have been preserved to turn /// any ambiguous whitespace into a concrete choice.a|a|aaa a`l`lkak/// Tries to find an existing chunk to append [comment] to. /// /// If [comment] should be appending to an existing line (in other words, /// should be moved before a split), then this returns that [Chunk]. /// Otherwise, returns `null`.gggffہTg/// Returns `true` if [comment] appears to be a magic generic method comment. /// /// Those get spaced a little differently to look more like real syntax: /// /// int f/**/(int x) => 3;jjjjj jh3h3je/// Returns `true` if a space should be output between the end of the current /// output and the subsequent comment which is about to be written. /// /// This is only called if the comment is trailing text in the unformatted /// source. In most cases, a space will be output to separate the comment /// from what precedes it. This returns false if: /// /// * This comment does begin the line in the output even if it didn't in /// the source. /// * The comment is a block comment immediately following a grouping /// character (`(`, `[`, or `{`). This is to allow `foo(/* comment */)`, /// et. al.mmmmm mm'm'm/// Returns `true` if a space should be output after the last comment which /// was just written and the token that will be written.pDpDpRp"p"p'rSrSrXrmrmrrrrrrrrrrrrar}rrqq߅6r?S/// Starts a new chunk with the given split information. /// /// Returns the chunk.ww www wwww`/// Writes [text] to either the current chunk or a new one if the current /// chunk is complete.xxxxxyy y yy$y$y)yy1xxȁxxzDzDN{U/// Pre-processes the chunks after they are done being written by the visitor /// but before they are run through the line splitter. /// /// Marks ranges of chunks that can be line split independently to keep the /// batches we send to [LineSplitter] small.} } }&||y}u/// Returns true if we can divide the chunks at [index] and line split the /// ones before and after that separately.]B/// Hardens the active rules when a hard split occurs within them./// Replaces all of the previously hardened rules with hard splits, along /// with every rule that those constrain to also split. /// /// This should only be called after all chunks have been written.DD5/// Takes the incremental serialized output of [SourceVisitor]--the source text /// along with any comments and preserved whitespace--and produces a coherent /// tree of [Chunk]s which can then be split into physical lines. /// /// Keeps track of leading indentation, expression nesting, and all of the hairy /// code required to seamlessly integrate existing comments into the pure /// output produced by [SourceVisitor].>I/// Matches if the last character of a string is an identifier character.;AaB)À)_/// Matches a JavaDoc-style doc comment that starts with "/**" and ends with /// "*/" or "**/".ʃЃރуezO/// Matches the leading "*" in a line in the middle of a JavaDoc-style comment.06@7_1/// Matches spaces at the beginning of as string.N؀ &?]{ҁ$=>‚Ã#deCD$(yÅ"#tdžȆGciRqrLjȉ$%`f܉݊)FL6~ʌ:;njȍ -.Glm56GǏ͏eՐ֑3RswxƑ/5ϓflr DJ-u•ߕ6,DEl—×:ՙ#m|ݚ)DHIL4|ќ 3OUV267 SYIޡ3IPho Q΢ݣ>ZmyӤk#*:N`g"HdjkSߧEf$*+f0K!p̫֫ClҭA^֭$./߯-56`H^İ8R]p&./Ka -pH 9`ntuյֶNuvط (DNVW7?@W]^[_`ûĻ1^ɼ;Y۾ *cimnܾ@nǿ˿̿@6@V@@@@@@AA>ADAAAAB.BSBhBiBBBBBBBCC"C(C,C-CxC~CDDiDDEE[EEEFF8F>FFGG8GKGLGgGGGGGH&H_HeHHHIIIIFIJIKIIIJ+JcJJJJJK5KmKsKKL%LELFLLLLMMGMMMQMRMMMNNNNlNNNNOOOROmOPPKP]PPQQQ:Q;QQQQQRKRrRRRRRRRSCSISST,TcTiTTTTU<UkUUUVV)V?VbVVVVWWWNWWX0XMX^XhXpXvXwXXYY:YMYQYRYYYYYZ Z Z0ZZZ~ZZZZZ[$[%[>[X[[[[\.\\\\\\\\] ]&]\]]]]]]]]^^$^`^d^e^^__7_V_____``8`e`i`j```aAabaaaab%bTbUbbccc!c"cscdd#dAd_dddde e;eeeeef3fQfofffffffg)g/gzgggh,h0h1hhhiifiiijjNjjjkk7k[k\kkkl l9lkllllm m$m%msmmnnLnMnynznnooooiooooopppp p]ppppq!q"qdqqqqqqrrr7rLrgrrrrrs@ssstKtgthtttuu6u@uHuIuuuvvvRvvvvvvwwwwwcw|wwwxxxx;xAxBxxxxxxxy;ynyoyyz z z+z=zAzBzzz{{N{g{{|||6|T|||||}}/}W}}}}}~~<~=~~~~ Vr12~BH Ar?IQWX&Ifntxz_trailingIdentifierChar_javaDocComment _javaDocLine_leadingIndentation ChunkBuilder