Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📁 catmsg	-	2025-05-25 12:27
📁 cldrtree	-	2025-05-25 12:27
📁 colltab	-	2025-05-25 12:27
📁 export	-	2025-05-25 12:27
📁 format	-	2025-05-25 12:27
📁 gen	-	2025-05-25 12:27
📄 internal.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package internal contains non-exported functionality that are used by // packages in the text repository. package internal // import "golang.org/x/text/internal" import ( "sort" "golang.org/x/text/language" ) // SortTags sorts tags in place. func SortTags(tags []language.Tag) { sort.Sort(sorter(tags)) } type sorter []language.Tag func (s sorter) Len() int { return len(s) } func (s sorter) Swap(i, j int) { s[i], s[j] = s[j], s[i] } func (s sorter) Less(i, j int) bool { return s[i].String() < s[j].String() } // UniqueTags sorts and filters duplicate tags in place and returns a slice with // only unique tags. func UniqueTags(tags []language.Tag) []language.Tag { if len(tags) <= 1 { return tags } SortTags(tags) k := 0 for i := 1; i < len(tags); i++ { if tags[k].String() < tags[i].String() { k++ tags[k] = tags[i] } } return tags[:k+1] }	1.02 KB	2025-05-25 12:27
📄 internal_test.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package internal import ( "fmt" "strings" "testing" "golang.org/x/text/language" ) func TestUnique(t *testing.T) { testCases := []struct { in, want string }{ {"", "[]"}, {"en", "[en]"}, {"en en", "[en]"}, {"en en en", "[en]"}, {"en-u-cu-eur en", "[en en-u-cu-eur]"}, {"nl en", "[en nl]"}, {"pt-Pt pt", "[pt pt-PT]"}, } for _, tc := range testCases { tags := []language.Tag{} for _, s := range strings.Split(tc.in, " ") { if s != "" { tags = append(tags, language.MustParse(s)) } } if got := fmt.Sprint(UniqueTags(tags)); got != tc.want { t.Errorf("Unique(%s) = %s; want %s", tc.in, got, tc.want) } } }	813 B	2025-05-25 12:27
📁 language	-	2025-05-25 12:27
📄 match.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package internal // This file contains matchers that implement CLDR inheritance. // // See https://unicode.org/reports/tr35/#Locale_Inheritance. // // Some of the inheritance described in this document is already handled by // the cldr package. import ( "golang.org/x/text/language" ) // TODO: consider if (some of the) matching algorithm needs to be public after // getting some feel about what is generic and what is specific. // NewInheritanceMatcher returns a matcher that matches based on the inheritance // chain. // // The matcher uses canonicalization and the parent relationship to find a // match. The resulting match will always be either Und or a language with the // same language and script as the requested language. It will not match // languages for which there is understood to be mutual or one-directional // intelligibility. // // A Match will indicate an Exact match if the language matches after // canonicalization and High if the matched tag is a parent. func NewInheritanceMatcher(t []language.Tag) *InheritanceMatcher { tags := &InheritanceMatcher{make(map[language.Tag]int)} for i, tag := range t { ct, err := language.All.Canonicalize(tag) if err != nil { ct = tag } tags.index[ct] = i } return tags } type InheritanceMatcher struct { index map[language.Tag]int } func (m InheritanceMatcher) Match(want ...language.Tag) (language.Tag, int, language.Confidence) { for _, t := range want { ct, err := language.All.Canonicalize(t) if err != nil { ct = t } conf := language.Exact for { if index, ok := m.index[ct]; ok { return ct, index, conf } if ct == language.Und { break } ct = ct.Parent() conf = language.High } } return language.Und, 0, language.No }	1.87 KB	2025-05-25 12:27
📄 match_test.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package internal import ( "strings" "testing" "golang.org/x/text/language" ) func TestInheritanceMatcher(t *testing.T) { for i, tt := range []struct { haveTags string wantTags string match string conf language.Confidence }{ {"und,en,en-US", "en-US", "en-US", language.Exact}, // most specific match {"zh-Hant,zh", "zh-TW", "zh-Hant", language.High}, // zh-TW implies Hant. {"und,zh", "zh-TW", "und", language.High}, // zh-TW does not match zh. {"zh", "zh-TW", "und", language.No}, // zh-TW does not match zh. {"iw,en,nl", "he", "he", language.Exact}, // matches after canonicalization {"he,en,nl", "iw", "he", language.Exact}, // matches after canonicalization // Prefer first match over more specific match for various reasons: // a) consistency of user interface is more important than an exact match, // b) _if_ und is specified, it should be considered a correct and useful match, // Note that a call to this Match will almost always be with a single tag. {"und,en,en-US", "he,en-US", "und", language.High}, } { have := parseTags(tt.haveTags) m := NewInheritanceMatcher(have) tag, index, conf := m.Match(parseTags(tt.wantTags)...) want := language.Raw.Make(tt.match) if tag != want { t.Errorf("%d:tag: got %q; want %q", i, tag, want) } if conf != language.No { if got, _ := language.All.Canonicalize(have[index]); got != want { t.Errorf("%d:index: got %q; want %q ", i, got, want) } } if conf != tt.conf { t.Errorf("%d:conf: got %v; want %v", i, conf, tt.conf) } } } func parseTags(list string) (out []language.Tag) { for _, s := range strings.Split(list, ",") { out = append(out, language.Raw.Make(strings.TrimSpace(s))) } return out }	1.89 KB	2025-05-25 12:27
📁 number	-	2025-05-25 12:27
📁 stringset	-	2025-05-25 12:27
📁 tag	-	2025-05-25 12:27
📁 testtext	-	2025-05-25 12:27
📁 triegen	-	2025-05-25 12:27
📁 ucd	-	2025-05-25 12:27
📁 utf8internal	-	2025-05-25 12:27

Terminal