// After implements Clock.
15119
func (System) After(d time.Duration) <-chan time.Time {
	return time.After(d)
}
558436
func (c *Compiler) WithStageAfter(after string, stage CompilerStage) *Compiler {
	c.after[after] = append(c.after[after], stage)
	return c
}
729351
func (c *Call) After(preReq *Call) *Call {
	c.t.Helper()

	if c == preReq {
		c.t.Fatalf("A call isn't allowed to be its own prerequisite")
	}
	if preReq.isPreReq(c) {
		c.t.Fatalf("Loop in call order: %v is a prerequisite to %v (possibly indirectly).", c, preReq)
	}

	c.preReqs = append(c.preReqs, preReq)
	return c
}
720477
func (RealClock) Since(ts time.Time) time.Duration {
	return time.Since(ts)
}
752903
func After(timeout time.Duration) <-chan time.Time {
	if timeout == Forever {
		return nil
	} else {
		return time.After(timeout)
	}
}
176055
func (F *Frisby) AfterText(foo AfterTextFunc) *Frisby {
	text, err := F.Resp.Text()
	foo(F, text, err)
	return F
}
671940
func (d Date) After(e Date) bool {
	return d.t.After(e.t)
}
324747
func (pb *ProgressBar) SetPrintAfter(after string) {
	pb.lock.Lock()
	pb.printAfter = after
	pb.lock.Unlock()
}
299893
func afterAfterFramesetIM(p *parser) bool {
	switch p.tok.Type {
	case CommentToken:
		p.doc.AppendChild(&Node{
			Type: CommentNode,
			Data: p.tok.Data,
		})
	case TextToken:
		// Ignore all text but whitespace.
		s := strings.Map(func(c rune) rune {
			switch c {
			case ' ', '\t', '\n', '\f', '\r':
				return c
			}
			return -1
		}, p.tok.Data)
		if s != "" {
			p.tok.Data = s
			return inBodyIM(p)
		}
	case StartTagToken:
		switch p.tok.DataAtom {
		case a.Html:
			return inBodyIM(p)
		case a.Noframes:
			return inHeadIM(p)
		}
	case DoctypeToken:
		return inBodyIM(p)
	default:
		// Ignore the token.
	}
	return true
}
832541
func After(f func(context.Context, ...*cdp.Node) error) QueryOption {
	return func(s *Selector) {
		s.after = f
	}
}
1178364
func (p Pos) After(u Pos) bool {
	return u.Offset < p.Offset || u.Line < p.Line
}
30843
func (s *Selection) AfterSelection(sel *Selection) *Selection {
	return s.AfterNodes(sel.Nodes...)
}
1013515
func (t *Timer) Since(start time.Time) {
	t.Update(time.Since(start))
}
93850
func MinTime(a, b time.Time) time.Time {
	if a.After(b) {
		return b
	}
	return a
}
1373170
func (m *mockTicker) wait(ready chan<- struct{}) {
	for i := time.Duration(1); true; i++ {
		delta := m.start.Add(m.interval * i).Sub(m.clock.Now())
		afterChan := m.clock.After(delta)

		if i == time.Duration(1) {
			ready <- struct{}{}
		}

		select {
		case <-m.stop:
			return
		case <-afterChan:
			select {
			case m.c <- m.clock.Now():
			case <-m.stop:
				return
			}
		}
	}
}
86065
func (s Suite) After(f func(*testing.T)) bool {
	return s("", func(t *testing.T, _ G, _ S) {
		t.Helper()
		f(t)
	}, func(c *config) { c.after = true })
}
246812
func (i *IntervalClock) Since(ts time.Time) time.Duration {
	return i.Time.Sub(ts)
}