_splitter _ruleValues _boundRules _unboundRules _liveRulessplits_splits overflowChars_overflowChars _isComplete _constraints_unboundConstraints_boundRulesInUnboundLinesgetValue isBetterThancompareOverlapexpand_isOverlapping_calculateSplits_calculateCost _addLiveRules_initBoundRulesInUnboundLines_initConstraints_initUnboundConstraintstoString SolveStateX LineSplitterRuleSetRule_ensureConstraints_ensureUnboundConstraintsSetSplitSetintboolMapunsplitgetValue overflowCharscostsplitsrulesrule _ruleValues compareTo StateErrorvoidclonecontainsvalue numValuesListtryBindadd _isComplete _liveRulesaddAllenqueuelength_boundRulesInUnboundLines _constraintskeys_unboundConstraints NestingLevelichunksisSplitnestingmarkclearTotalUsedIndentrefreshTotalUsedIndentunmark flushLeftblockIndentationindenttotalUsedIndent indentBlockIndent expressionlineswriter pageWidthSpan shouldSplitAtspansspan identical getColumnspaceWhenUnsplit BlockChunk formatBlockunsplitBlockLengthtextforEachsetCostallConstrainedRules constrainedclearboundconstrainedRulesunbound constrain mustSplitoverrideString StringBufferwriteAllmapfullySplitValuepadLeftboldgraywritetoStringaK1JN ../chunk.dart../constants.dart #&debug& ../debug.dart.../nesting_level.dartN../rule/rule.dartjline_splitter.dart rule_set.dart P߂JN؀ -Mi3̃fKVi4RSQgmGagNۉ*u{ʊhȊ΋j֋׌(GHь8U[A]xyÎ؏c<Ցnag:mƓޓ;c,u˕̖7iopĖȖɖQ9Y_ &u™֙ܚiכ#ntĜ%NxyМ78{ҞAEFܟ)vǟ0HpסGHnc 2Yʣˤ:BCv3zݦQfĦئަߧZħʧ˨>ר#VڪABACAAABBBBpBBBBBC$CWCXCuCCCCCD DD6D>DDDEDtDDDDDDEHEEEEEF F3FRFaFFFFFFFGGHGIGzGGHH HHHH4H8H9HHHHI6IhIIJ JRJSJJJJJK5KqKrKKL L LZLLMMJMMMMMMMMMNNNN)N?N`NaNNNNO O=OEOFOpOOOOOOP PPPAPBPPPPPP '&-MiO?\\/// A possibly incomplete solution in the line splitting search space. /// /// A single [SolveState] binds some subset of the rules to values while /// leaving the rest unbound. If every rule is bound, the solve state describes /// a complete solution to the line splitting problem. Even if rules are /// unbound, a state can also usually be used as a solution by treating all /// unbound rules as unsplit. (The usually is because a state that constrains /// an unbound rule to split can't be used with that rule unsplit.) /// /// From a given solve state, we can explore the search tree to more refined /// solve states by producing new ones that add more bound rules to the current /// state.` k~~EE/// The set of [Rule]s that are bound by [_ruleValues]. /// /// Cached by [_ensureConstraints] for use by [_ensureUnboundConstraints].U/// The set of [Rule]s that are not bound by [_ruleValues]. /// /// Cached by [_ensureConstraints] for use by [_ensureUnboundConstraints].͋}/// The unbound rules in this state that can be bound to produce new more /// refined states. /// /// Keeping this set small is the key to make the entire line splitter /// perform well. If we consider too many rules at each state, our /// exploration of the solution space is too branchy and we waste time on /// dead end solutions. /// /// Here is the key insight. The line splitter treats any unbound rule as /// being unsplit. This means refining a solution always means taking a rule /// that is unsplit and making it split. That monotonically increases the /// cost, but may help fit the solution inside the page. /// /// We want to keep the cost low, so the only reason to consider making a /// rule split is if it reduces an overflowing line. It's also the case that /// splitting an earlier rule will often reshuffle the rest of the line. /// /// Taking that into account, the only rules we consider binding to extend a /// solve state are *unbound rules inside the first line that is overflowing*. /// Even if a line has dozens of rules, this generally keeps the branching /// down to a few. It also means rules inside lines that already fit are /// never touched. /// /// There is one other set of rules that go in here. Sometimes a bound rule /// in the solve state constrains some other unbound rule to split. In that /// case, we also consider that active so we know to not leave it at zero.ҋӋ̋ы͌*>>ddb/// Whether we can treat this state as a complete solution by leaving its /// unbound rules unsplit. /// /// This is generally true but will be false if the state contains any /// unbound rules that are constrained to not be zero by other bound rules. /// This avoids picking a solution that leaves those rules at zero when they /// aren't allowed to be.r{Z/// The constraints the bound rules in this state have on the remaining /// unbound rules.ۂ/// The unbound rule values that are disallowed because they would place /// invalid constraints on the currently bound values. /// /// For example, say rule A is bound to 1 and B is unbound. If B has value /// 1, it constrains A to be 1. Likewise, if B is 2, it constrains A to be /// 2 as well. Since we already know A is 1, that means we know B cannot be /// bound to value 2. This means B is more limited in this state than it /// might be in another state that binds A to a different value. /// /// It's important to track this, because we can't allow to states to overlap /// if one permits more values for some unbound rule than the other does.}QQ/// The bound rules that appear inside lines also containing unbound rules. /// /// By appearing in the same line, it means these bound rules may affect the /// results of binding those unbound rules. This is used to tell if two /// states may diverge by binding unbound rules or not.sN,/// The set of splits chosen for this state.JY/// The number of characters that do not fit inside the page with this set of /// splits. iie/// Gets the value to use for [rule], either the bound value or /// [Rule.unsplit] if it isn't bound.r xw(  b/// Returns `true` if this state is a better solution to use as the final /// result than [other].$#ˇy++#/// Determines if this state "overlaps" [other]. /// /// Two states overlap if they currently have the same score and we can tell /// for certain that they won't diverge as their unbound rules are bound. If /// that's the case, then whichever state is better now (based on their /// currently bound rule values) is the one that will always win, regardless /// of how they get expanded. /// /// In other words, their entire expanded solution trees also overlap. In /// that case, there's no point in expanding both, so we can just pick the /// winner now and discard the other. /// /// For this to be true, we need to prove that binding an unbound rule won't /// affect one state differently from the other. We have to show that they /// are parallel. /// /// Two things could cause this *not* to be the case. /// /// 1. If one state's bound rules place different constraints on the unbound /// rules than the other. /// /// 2. If one state's different bound rules are in the same line as an /// unbound rule. That affects the indentation and length of the line, /// which affects the context where the unbound rule is being chosen. /// /// If neither of these is the case, the states overlap. Returns `<0` if this /// state is better, or `>0` if [other] wins. If the states do not overlap, /// returns `0`.:FEH^b/// Enqueues more solve states to consider based on this one. /// /// For each unbound rule in this state that occurred in the first long line, /// enqueue solve states that bind that rule to each value it can have and /// bind all previous rules to zero. (In other words, try all subsolutions /// where that rule becomes the first new rule to split at.)2/// Returns `true` if [other] overlaps this state.c|c/// Calculates the [SplitSet] for this solve state, assuming any unbound /// rules are set to zero.wzz/// Evaluates the cost (i.e. the relative "badness") of splitting the line /// into [lines] physical lines based on the current set of rules.^@&@&/// Adds [rule] and all of the rules it constrains to the set of [_liveRules]. /// /// Only does this if [rule] is a valid soft rule. Returns `true` if any new /// live rules were added.@4 @;@:AEDBNBN/// Used to lazy initialize [_boundRulesInUnboundLines], which is needed to /// compare two states for overlap. /// /// We do this lazily because the calculation is a bit slow, and is only /// needed when we have two states with the same score.DEE/// Used to lazy initializes the [_constraints], which is needed to compare /// two states for overlap. /// /// We do this lazily because the calculation is a bit slow, and is only /// needed when we have two states with the same score.H;ILIL/// Used to lazy initialize the [_unboundConstraints], which is needed to /// compare two states for overlap. /// /// We do this lazily because the calculation is a bit slow, and is only /// needed when we have two states with the same score.NN2N2NN JN؀ -Mi3̃fKVi4RSQgmGagNۉ*u{ʊhȊ΋j֋׌(GHь8U[A]xyÎ؏c<Ցnag:mƓޓ;c,u˕̖7iopĖȖɖQ9Y_ &u™֙ܚiכ#ntĜ%NxyМ78{ҞAEFܟ)vǟ0HpסGHnc 2Yʣˤ:BCv3zݦQfĦئަߧZħʧ˨>ר#VڪABACAAABBBBpBBBBBC$CWCXCuCCCCCD DD6D>DDDEDtDDDDDDEHEEEEEF F3FRFaFFFFFFFGGHGIGzGGHH HHHH4H8H9HHHHI6IhIIJ JRJSJJJJJK5KqKrKKL L LZLLMMJMMMMMMMMMNNNN)N?N`NaNNNNO O=OEOFOpOOOOOOP PPPAPBPPPPPP SolveState!