aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/golang.org/x/text/secure
diff options
context:
space:
mode:
authorLibravatar Rutger Broekhoff2024-01-02 18:56:31 +0100
committerLibravatar Rutger Broekhoff2024-01-02 18:56:31 +0100
commit8db41da676ac8368ef7c2549d56239a5ff5eedde (patch)
tree09c427fd66de2ec1ebffc8342f5fdbb84b0701b5 /vendor/golang.org/x/text/secure
parentd4f75fb6db22e57577867445a022227e70958931 (diff)
downloadgitolfs3-8db41da676ac8368ef7c2549d56239a5ff5eedde.tar.gz
gitolfs3-8db41da676ac8368ef7c2549d56239a5ff5eedde.zip
Delete vendor directory
Diffstat (limited to 'vendor/golang.org/x/text/secure')
-rw-r--r--vendor/golang.org/x/text/secure/bidirule/bidirule.go336
-rw-r--r--vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go11
-rw-r--r--vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go14
3 files changed, 0 insertions, 361 deletions
diff --git a/vendor/golang.org/x/text/secure/bidirule/bidirule.go b/vendor/golang.org/x/text/secure/bidirule/bidirule.go
deleted file mode 100644
index e2b70f7..0000000
--- a/vendor/golang.org/x/text/secure/bidirule/bidirule.go
+++ /dev/null
@@ -1,336 +0,0 @@
1// Copyright 2016 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5// Package bidirule implements the Bidi Rule defined by RFC 5893.
6//
7// This package is under development. The API may change without notice and
8// without preserving backward compatibility.
9package bidirule
10
11import (
12 "errors"
13 "unicode/utf8"
14
15 "golang.org/x/text/transform"
16 "golang.org/x/text/unicode/bidi"
17)
18
19// This file contains an implementation of RFC 5893: Right-to-Left Scripts for
20// Internationalized Domain Names for Applications (IDNA)
21//
22// A label is an individual component of a domain name. Labels are usually
23// shown separated by dots; for example, the domain name "www.example.com" is
24// composed of three labels: "www", "example", and "com".
25//
26// An RTL label is a label that contains at least one character of class R, AL,
27// or AN. An LTR label is any label that is not an RTL label.
28//
29// A "Bidi domain name" is a domain name that contains at least one RTL label.
30//
31// The following guarantees can be made based on the above:
32//
33// o In a domain name consisting of only labels that satisfy the rule,
34// the requirements of Section 3 are satisfied. Note that even LTR
35// labels and pure ASCII labels have to be tested.
36//
37// o In a domain name consisting of only LDH labels (as defined in the
38// Definitions document [RFC5890]) and labels that satisfy the rule,
39// the requirements of Section 3 are satisfied as long as a label
40// that starts with an ASCII digit does not come after a
41// right-to-left label.
42//
43// No guarantee is given for other combinations.
44
45// ErrInvalid indicates a label is invalid according to the Bidi Rule.
46var ErrInvalid = errors.New("bidirule: failed Bidi Rule")
47
48type ruleState uint8
49
50const (
51 ruleInitial ruleState = iota
52 ruleLTR
53 ruleLTRFinal
54 ruleRTL
55 ruleRTLFinal
56 ruleInvalid
57)
58
59type ruleTransition struct {
60 next ruleState
61 mask uint16
62}
63
64var transitions = [...][2]ruleTransition{
65 // [2.1] The first character must be a character with Bidi property L, R, or
66 // AL. If it has the R or AL property, it is an RTL label; if it has the L
67 // property, it is an LTR label.
68 ruleInitial: {
69 {ruleLTRFinal, 1 << bidi.L},
70 {ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL},
71 },
72 ruleRTL: {
73 // [2.3] In an RTL label, the end of the label must be a character with
74 // Bidi property R, AL, EN, or AN, followed by zero or more characters
75 // with Bidi property NSM.
76 {ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL | 1<<bidi.EN | 1<<bidi.AN},
77
78 // [2.2] In an RTL label, only characters with the Bidi properties R,
79 // AL, AN, EN, ES, CS, ET, ON, BN, or NSM are allowed.
80 // We exclude the entries from [2.3]
81 {ruleRTL, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN | 1<<bidi.NSM},
82 },
83 ruleRTLFinal: {
84 // [2.3] In an RTL label, the end of the label must be a character with
85 // Bidi property R, AL, EN, or AN, followed by zero or more characters
86 // with Bidi property NSM.
87 {ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL | 1<<bidi.EN | 1<<bidi.AN | 1<<bidi.NSM},
88
89 // [2.2] In an RTL label, only characters with the Bidi properties R,
90 // AL, AN, EN, ES, CS, ET, ON, BN, or NSM are allowed.
91 // We exclude the entries from [2.3] and NSM.
92 {ruleRTL, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN},
93 },
94 ruleLTR: {
95 // [2.6] In an LTR label, the end of the label must be a character with
96 // Bidi property L or EN, followed by zero or more characters with Bidi
97 // property NSM.
98 {ruleLTRFinal, 1<<bidi.L | 1<<bidi.EN},
99
100 // [2.5] In an LTR label, only characters with the Bidi properties L,
101 // EN, ES, CS, ET, ON, BN, or NSM are allowed.
102 // We exclude the entries from [2.6].
103 {ruleLTR, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN | 1<<bidi.NSM},
104 },
105 ruleLTRFinal: {
106 // [2.6] In an LTR label, the end of the label must be a character with
107 // Bidi property L or EN, followed by zero or more characters with Bidi
108 // property NSM.
109 {ruleLTRFinal, 1<<bidi.L | 1<<bidi.EN | 1<<bidi.NSM},
110
111 // [2.5] In an LTR label, only characters with the Bidi properties L,
112 // EN, ES, CS, ET, ON, BN, or NSM are allowed.
113 // We exclude the entries from [2.6].
114 {ruleLTR, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN},
115 },
116 ruleInvalid: {
117 {ruleInvalid, 0},
118 {ruleInvalid, 0},
119 },
120}
121
122// [2.4] In an RTL label, if an EN is present, no AN may be present, and
123// vice versa.
124const exclusiveRTL = uint16(1<<bidi.EN | 1<<bidi.AN)
125
126// From RFC 5893
127// An RTL label is a label that contains at least one character of type
128// R, AL, or AN.
129//
130// An LTR label is any label that is not an RTL label.
131
132// Direction reports the direction of the given label as defined by RFC 5893.
133// The Bidi Rule does not have to be applied to labels of the category
134// LeftToRight.
135func Direction(b []byte) bidi.Direction {
136 for i := 0; i < len(b); {
137 e, sz := bidi.Lookup(b[i:])
138 if sz == 0 {
139 i++
140 }
141 c := e.Class()
142 if c == bidi.R || c == bidi.AL || c == bidi.AN {
143 return bidi.RightToLeft
144 }
145 i += sz
146 }
147 return bidi.LeftToRight
148}
149
150// DirectionString reports the direction of the given label as defined by RFC
151// 5893. The Bidi Rule does not have to be applied to labels of the category
152// LeftToRight.
153func DirectionString(s string) bidi.Direction {
154 for i := 0; i < len(s); {
155 e, sz := bidi.LookupString(s[i:])
156 if sz == 0 {
157 i++
158 continue
159 }
160 c := e.Class()
161 if c == bidi.R || c == bidi.AL || c == bidi.AN {
162 return bidi.RightToLeft
163 }
164 i += sz
165 }
166 return bidi.LeftToRight
167}
168
169// Valid reports whether b conforms to the BiDi rule.
170func Valid(b []byte) bool {
171 var t Transformer
172 if n, ok := t.advance(b); !ok || n < len(b) {
173 return false
174 }
175 return t.isFinal()
176}
177
178// ValidString reports whether s conforms to the BiDi rule.
179func ValidString(s string) bool {
180 var t Transformer
181 if n, ok := t.advanceString(s); !ok || n < len(s) {
182 return false
183 }
184 return t.isFinal()
185}
186
187// New returns a Transformer that verifies that input adheres to the Bidi Rule.
188func New() *Transformer {
189 return &Transformer{}
190}
191
192// Transformer implements transform.Transform.
193type Transformer struct {
194 state ruleState
195 hasRTL bool
196 seen uint16
197}
198
199// A rule can only be violated for "Bidi Domain names", meaning if one of the
200// following categories has been observed.
201func (t *Transformer) isRTL() bool {
202 const isRTL = 1<<bidi.R | 1<<bidi.AL | 1<<bidi.AN
203 return t.seen&isRTL != 0
204}
205
206// Reset implements transform.Transformer.
207func (t *Transformer) Reset() { *t = Transformer{} }
208
209// Transform implements transform.Transformer. This Transformer has state and
210// needs to be reset between uses.
211func (t *Transformer) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
212 if len(dst) < len(src) {
213 src = src[:len(dst)]
214 atEOF = false
215 err = transform.ErrShortDst
216 }
217 n, err1 := t.Span(src, atEOF)
218 copy(dst, src[:n])
219 if err == nil || err1 != nil && err1 != transform.ErrShortSrc {
220 err = err1
221 }
222 return n, n, err
223}
224
225// Span returns the first n bytes of src that conform to the Bidi rule.
226func (t *Transformer) Span(src []byte, atEOF bool) (n int, err error) {
227 if t.state == ruleInvalid && t.isRTL() {
228 return 0, ErrInvalid
229 }
230 n, ok := t.advance(src)
231 switch {
232 case !ok:
233 err = ErrInvalid
234 case n < len(src):
235 if !atEOF {
236 err = transform.ErrShortSrc
237 break
238 }
239 err = ErrInvalid
240 case !t.isFinal():
241 err = ErrInvalid
242 }
243 return n, err
244}
245
246// Precomputing the ASCII values decreases running time for the ASCII fast path
247// by about 30%.
248var asciiTable [128]bidi.Properties
249
250func init() {
251 for i := range asciiTable {
252 p, _ := bidi.LookupRune(rune(i))
253 asciiTable[i] = p
254 }
255}
256
257func (t *Transformer) advance(s []byte) (n int, ok bool) {
258 var e bidi.Properties
259 var sz int
260 for n < len(s) {
261 if s[n] < utf8.RuneSelf {
262 e, sz = asciiTable[s[n]], 1
263 } else {
264 e, sz = bidi.Lookup(s[n:])
265 if sz <= 1 {
266 if sz == 1 {
267 // We always consider invalid UTF-8 to be invalid, even if
268 // the string has not yet been determined to be RTL.
269 // TODO: is this correct?
270 return n, false
271 }
272 return n, true // incomplete UTF-8 encoding
273 }
274 }
275 // TODO: using CompactClass would result in noticeable speedup.
276 // See unicode/bidi/prop.go:Properties.CompactClass.
277 c := uint16(1 << e.Class())
278 t.seen |= c
279 if t.seen&exclusiveRTL == exclusiveRTL {
280 t.state = ruleInvalid
281 return n, false
282 }
283 switch tr := transitions[t.state]; {
284 case tr[0].mask&c != 0:
285 t.state = tr[0].next
286 case tr[1].mask&c != 0:
287 t.state = tr[1].next
288 default:
289 t.state = ruleInvalid
290 if t.isRTL() {
291 return n, false
292 }
293 }
294 n += sz
295 }
296 return n, true
297}
298
299func (t *Transformer) advanceString(s string) (n int, ok bool) {
300 var e bidi.Properties
301 var sz int
302 for n < len(s) {
303 if s[n] < utf8.RuneSelf {
304 e, sz = asciiTable[s[n]], 1
305 } else {
306 e, sz = bidi.LookupString(s[n:])
307 if sz <= 1 {
308 if sz == 1 {
309 return n, false // invalid UTF-8
310 }
311 return n, true // incomplete UTF-8 encoding
312 }
313 }
314 // TODO: using CompactClass results in noticeable speedup.
315 // See unicode/bidi/prop.go:Properties.CompactClass.
316 c := uint16(1 << e.Class())
317 t.seen |= c
318 if t.seen&exclusiveRTL == exclusiveRTL {
319 t.state = ruleInvalid
320 return n, false
321 }
322 switch tr := transitions[t.state]; {
323 case tr[0].mask&c != 0:
324 t.state = tr[0].next
325 case tr[1].mask&c != 0:
326 t.state = tr[1].next
327 default:
328 t.state = ruleInvalid
329 if t.isRTL() {
330 return n, false
331 }
332 }
333 n += sz
334 }
335 return n, true
336}
diff --git a/vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go b/vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go
deleted file mode 100644
index 784bb88..0000000
--- a/vendor/golang.org/x/text/secure/bidirule/bidirule10.0.0.go
+++ /dev/null
@@ -1,11 +0,0 @@
1// Copyright 2016 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5//go:build go1.10
6
7package bidirule
8
9func (t *Transformer) isFinal() bool {
10 return t.state == ruleLTRFinal || t.state == ruleRTLFinal || t.state == ruleInitial
11}
diff --git a/vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go b/vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go
deleted file mode 100644
index 8e1e943..0000000
--- a/vendor/golang.org/x/text/secure/bidirule/bidirule9.0.0.go
+++ /dev/null
@@ -1,14 +0,0 @@
1// Copyright 2016 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5//go:build !go1.10
6
7package bidirule
8
9func (t *Transformer) isFinal() bool {
10 if !t.isRTL() {
11 return true
12 }
13 return t.state == ruleLTRFinal || t.state == ruleRTLFinal || t.state == ruleInitial
14}
generated by cgit v1.2.3 (git 2.45.2) at 2024-11-18 23:05:47 +0000