-
-
Notifications
You must be signed in to change notification settings - Fork 347
/
a_patch.go
158 lines (132 loc) · 3.14 KB
/
a_patch.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
// Patches to normalize the proto types
package proto
import (
"time"
)
// TimeSinceEpoch UTC time in seconds, counted from January 1, 1970.
// To convert a time.Time to TimeSinceEpoch, for example:
// proto.TimeSinceEpoch(time.Now().Unix())
// For session cookie, the value should be -1.
type TimeSinceEpoch float64
// Time interface
func (t TimeSinceEpoch) Time() time.Time {
return (time.Unix(0, 0)).Add(
time.Duration(t * TimeSinceEpoch(time.Second)),
)
}
// String interface
func (t TimeSinceEpoch) String() string {
return t.Time().String()
}
// MonotonicTime Monotonically increasing time in seconds since an arbitrary point in the past.
type MonotonicTime float64
// Duration interface
func (t MonotonicTime) Duration() time.Duration {
return time.Duration(t * MonotonicTime(time.Second))
}
// String interface
func (t MonotonicTime) String() string {
return t.Duration().String()
}
// Point from the origin (0, 0)
type Point struct {
X float64 `json:"x"`
Y float64 `json:"y"`
}
// Len is the number of vertices
func (q DOMQuad) Len() int {
return len(q) / 2
}
// Each point
func (q DOMQuad) Each(fn func(pt Point, i int)) {
for i := 0; i < q.Len(); i++ {
fn(Point{q[i*2], q[i*2+1]}, i)
}
}
// Center of the polygon
func (q DOMQuad) Center() Point {
var x, y float64
q.Each(func(pt Point, _ int) {
x += pt.X
y += pt.Y
})
return Point{x / float64(q.Len()), y / float64(q.Len())}
}
// Area of the polygon
// https://en.wikipedia.org/wiki/Polygon#Area
func (q DOMQuad) Area() float64 {
area := 0.0
l := len(q)/2 - 1
for i := 0; i < l; i++ {
area += q[i*2]*q[i*2+3] - q[i*2+2]*q[i*2+1]
}
area += q[l*2]*q[1] - q[0]*q[l*2+1]
return area / 2
}
// OnePointInside the shape
func (res *DOMGetContentQuadsResult) OnePointInside() *Point {
for _, q := range res.Quads {
if q.Area() >= 1 {
pt := q.Center()
return &pt
}
}
return nil
}
// Box returns the smallest leveled rectangle that can cover the whole shape.
func (res *DOMGetContentQuadsResult) Box() (box *DOMRect) {
return Shape(res.Quads).Box()
}
// Shape is a list of DOMQuad
type Shape []DOMQuad
// Box returns the smallest leveled rectangle that can cover the whole shape.
func (qs Shape) Box() (box *DOMRect) {
if len(qs) == 0 {
return
}
left := qs[0][0]
top := qs[0][1]
right := left
bottom := top
for _, q := range qs {
q.Each(func(pt Point, _ int) {
if pt.X < left {
left = pt.X
}
if pt.Y < top {
top = pt.Y
}
if pt.X > right {
right = pt.X
}
if pt.Y > bottom {
bottom = pt.Y
}
})
}
box = &DOMRect{left, top, right - left, bottom - top}
return
}
// MoveTo X and Y to x and y
func (p *InputTouchPoint) MoveTo(x, y float64) {
p.X = x
p.Y = y
}
// CookiesToParams converts Cookies list to NetworkCookieParam list
func CookiesToParams(cookies []*NetworkCookie) []*NetworkCookieParam {
list := []*NetworkCookieParam{}
for _, c := range cookies {
list = append(list, &NetworkCookieParam{
Name: c.Name,
Value: c.Value,
Domain: c.Domain,
Path: c.Path,
Secure: c.Secure,
HTTPOnly: c.HTTPOnly,
SameSite: c.SameSite,
Expires: c.Expires,
Priority: c.Priority,
})
}
return list
}