dav.go 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533
  1. package dav
  2. import (
  3. "math"
  4. "strconv"
  5. "time"
  6. "github.com/go-playground/locales"
  7. "github.com/go-playground/locales/currency"
  8. )
  9. type dav struct {
  10. locale string
  11. pluralsCardinal []locales.PluralRule
  12. pluralsOrdinal []locales.PluralRule
  13. pluralsRange []locales.PluralRule
  14. decimal string
  15. group string
  16. minus string
  17. percent string
  18. perMille string
  19. timeSeparator string
  20. inifinity string
  21. currencies []string // idx = enum of currency code
  22. currencyNegativePrefix string
  23. currencyNegativeSuffix string
  24. monthsAbbreviated []string
  25. monthsNarrow []string
  26. monthsWide []string
  27. daysAbbreviated []string
  28. daysNarrow []string
  29. daysShort []string
  30. daysWide []string
  31. periodsAbbreviated []string
  32. periodsNarrow []string
  33. periodsShort []string
  34. periodsWide []string
  35. erasAbbreviated []string
  36. erasNarrow []string
  37. erasWide []string
  38. timezones map[string]string
  39. }
  40. // New returns a new instance of translator for the 'dav' locale
  41. func New() locales.Translator {
  42. return &dav{
  43. locale: "dav",
  44. pluralsCardinal: nil,
  45. pluralsOrdinal: nil,
  46. pluralsRange: nil,
  47. timeSeparator: ":",
  48. currencies: []string{"ADP", "AED", "AFA", "AFN", "ALK", "ALL", "AMD", "ANG", "AOA", "AOK", "AON", "AOR", "ARA", "ARL", "ARM", "ARP", "ARS", "ATS", "AUD", "AWG", "AZM", "AZN", "BAD", "BAM", "BAN", "BBD", "BDT", "BEC", "BEF", "BEL", "BGL", "BGM", "BGN", "BGO", "BHD", "BIF", "BMD", "BND", "BOB", "BOL", "BOP", "BOV", "BRB", "BRC", "BRE", "BRL", "BRN", "BRR", "BRZ", "BSD", "BTN", "BUK", "BWP", "BYB", "BYN", "BYR", "BZD", "CAD", "CDF", "CHE", "CHF", "CHW", "CLE", "CLF", "CLP", "CNH", "CNX", "CNY", "COP", "COU", "CRC", "CSD", "CSK", "CUC", "CUP", "CVE", "CYP", "CZK", "DDM", "DEM", "DJF", "DKK", "DOP", "DZD", "ECS", "ECV", "EEK", "EGP", "ERN", "ESA", "ESB", "ESP", "ETB", "EUR", "FIM", "FJD", "FKP", "FRF", "GBP", "GEK", "GEL", "GHC", "GHS", "GIP", "GMD", "GNF", "GNS", "GQE", "GRD", "GTQ", "GWE", "GWP", "GYD", "HKD", "HNL", "HRD", "HRK", "HTG", "HUF", "IDR", "IEP", "ILP", "ILR", "ILS", "INR", "IQD", "IRR", "ISJ", "ISK", "ITL", "JMD", "JOD", "JPY", "Ksh", "KGS", "KHR", "KMF", "KPW", "KRH", "KRO", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LTL", "LTT", "LUC", "LUF", "LUL", "LVL", "LVR", "LYD", "MAD", "MAF", "MCF", "MDC", "MDL", "MGA", "MGF", "MKD", "MKN", "MLF", "MMK", "MNT", "MOP", "MRO", "MTL", "MTP", "MUR", "MVP", "MVR", "MWK", "MXN", "MXP", "MXV", "MYR", "MZE", "MZM", "MZN", "NAD", "NGN", "NIC", "NIO", "NLG", "NOK", "NPR", "NZD", "OMR", "PAB", "PEI", "PEN", "PES", "PGK", "PHP", "PKR", "PLN", "PLZ", "PTE", "PYG", "QAR", "RHD", "ROL", "RON", "RSD", "RUB", "RUR", "RWF", "SAR", "SBD", "SCR", "SDD", "SDG", "SDP", "SEK", "SGD", "SHP", "SIT", "SKK", "SLL", "SOS", "SRD", "SRG", "SSP", "STD", "STN", "SUR", "SVC", "SYP", "SZL", "THB", "TJR", "TJS", "TMM", "TMT", "TND", "TOP", "TPE", "TRL", "TRY", "TTD", "TWD", "TZS", "UAH", "UAK", "UGS", "UGX", "USD", "USN", "USS", "UYI", "UYP", "UYU", "UZS", "VEB", "VEF", "VND", "VNN", "VUV", "WST", "XAF", "XAG", "XAU", "XBA", "XBB", "XBC", "XBD", "XCD", "XDR", "XEU", "XFO", "XFU", "XOF", "XPD", "XPF", "XPT", "XRE", "XSU", "XTS", "XUA", "XXX", "YDD", "YER", "YUD", "YUM", "YUN", "YUR", "ZAL", "ZAR", "ZMK", "ZMW", "ZRN", "ZRZ", "ZWD", "ZWL", "ZWR"},
  49. currencyNegativePrefix: "(",
  50. currencyNegativeSuffix: ")",
  51. monthsAbbreviated: []string{"", "Imb", "Kaw", "Kad", "Kan", "Kas", "Kar", "Mfu", "Wun", "Ike", "Iku", "Imw", "Iwi"},
  52. monthsNarrow: []string{"", "I", "K", "K", "K", "K", "K", "M", "W", "I", "I", "I", "I"},
  53. monthsWide: []string{"", "Mori ghwa imbiri", "Mori ghwa kawi", "Mori ghwa kadadu", "Mori ghwa kana", "Mori ghwa kasanu", "Mori ghwa karandadu", "Mori ghwa mfungade", "Mori ghwa wunyanya", "Mori ghwa ikenda", "Mori ghwa ikumi", "Mori ghwa ikumi na imweri", "Mori ghwa ikumi na iwi"},
  54. daysAbbreviated: []string{"Jum", "Jim", "Kaw", "Kad", "Kan", "Kas", "Ngu"},
  55. daysNarrow: []string{"J", "J", "K", "K", "K", "K", "N"},
  56. daysWide: []string{"Ituku ja jumwa", "Kuramuka jimweri", "Kuramuka kawi", "Kuramuka kadadu", "Kuramuka kana", "Kuramuka kasanu", "Kifula nguwo"},
  57. periodsAbbreviated: []string{"Luma lwa K", "luma lwa p"},
  58. periodsWide: []string{"Luma lwa K", "luma lwa p"},
  59. erasAbbreviated: []string{"KK", "BK"},
  60. erasNarrow: []string{"", ""},
  61. erasWide: []string{"Kabla ya Kristo", "Baada ya Kristo"},
  62. timezones: map[string]string{"HNCU": "HNCU", "SGT": "SGT", "HNEG": "HNEG", "ART": "ART", "WIT": "WIT", "UYST": "UYST", "AEST": "AEST", "HNT": "HNT", "WITA": "WITA", "EST": "EST", "OESZ": "OESZ", "EDT": "EDT", "CLT": "CLT", "CHAST": "CHAST", "PST": "PST", "SAST": "SAST", "WAT": "WAT", "BOT": "BOT", "GYT": "GYT", "HNPMX": "HNPMX", "NZST": "NZST", "GFT": "GFT", "ACDT": "ACDT", "HEOG": "HEOG", "IST": "IST", "AEDT": "AEDT", "MST": "MST", "WIB": "WIB", "TMT": "TMT", "HADT": "HADT", "AWST": "AWST", "LHDT": "LHDT", "HEPM": "HEPM", "CLST": "CLST", "OEZ": "OEZ", "WARST": "WARST", "HNPM": "HNPM", "EAT": "EAT", "HAT": "HAT", "ACWST": "ACWST", "MEZ": "MEZ", "HKST": "HKST", "HENOMX": "HENOMX", "ChST": "ChST", "CST": "CST", "WAST": "WAST", "LHST": "LHST", "HNNOMX": "HNNOMX", "VET": "VET", "CHADT": "CHADT", "WESZ": "WESZ", "AKST": "AKST", "ECT": "ECT", "WEZ": "WEZ", "WART": "WART", "CAT": "CAT", "TMST": "TMST", "HAST": "HAST", "COT": "COT", "MDT": "MDT", "NZDT": "NZDT", "MESZ": "MESZ", "BT": "BT", "HNOG": "HNOG", "HEPMX": "HEPMX", "PDT": "PDT", "AWDT": "AWDT", "MYT": "MYT", "HECU": "HECU", "CDT": "CDT", "JST": "JST", "HKT": "HKT", "SRT": "SRT", "COST": "COST", "GMT": "GMT", "AST": "AST", "ADT": "ADT", "∅∅∅": "∅∅∅", "UYT": "UYT", "ACWDT": "ACWDT", "HEEG": "HEEG", "ARST": "ARST", "JDT": "JDT", "AKDT": "AKDT", "ACST": "ACST"},
  63. }
  64. }
  65. // Locale returns the current translators string locale
  66. func (dav *dav) Locale() string {
  67. return dav.locale
  68. }
  69. // PluralsCardinal returns the list of cardinal plural rules associated with 'dav'
  70. func (dav *dav) PluralsCardinal() []locales.PluralRule {
  71. return dav.pluralsCardinal
  72. }
  73. // PluralsOrdinal returns the list of ordinal plural rules associated with 'dav'
  74. func (dav *dav) PluralsOrdinal() []locales.PluralRule {
  75. return dav.pluralsOrdinal
  76. }
  77. // PluralsRange returns the list of range plural rules associated with 'dav'
  78. func (dav *dav) PluralsRange() []locales.PluralRule {
  79. return dav.pluralsRange
  80. }
  81. // CardinalPluralRule returns the cardinal PluralRule given 'num' and digits/precision of 'v' for 'dav'
  82. func (dav *dav) CardinalPluralRule(num float64, v uint64) locales.PluralRule {
  83. return locales.PluralRuleUnknown
  84. }
  85. // OrdinalPluralRule returns the ordinal PluralRule given 'num' and digits/precision of 'v' for 'dav'
  86. func (dav *dav) OrdinalPluralRule(num float64, v uint64) locales.PluralRule {
  87. return locales.PluralRuleUnknown
  88. }
  89. // RangePluralRule returns the ordinal PluralRule given 'num1', 'num2' and digits/precision of 'v1' and 'v2' for 'dav'
  90. func (dav *dav) RangePluralRule(num1 float64, v1 uint64, num2 float64, v2 uint64) locales.PluralRule {
  91. return locales.PluralRuleUnknown
  92. }
  93. // MonthAbbreviated returns the locales abbreviated month given the 'month' provided
  94. func (dav *dav) MonthAbbreviated(month time.Month) string {
  95. return dav.monthsAbbreviated[month]
  96. }
  97. // MonthsAbbreviated returns the locales abbreviated months
  98. func (dav *dav) MonthsAbbreviated() []string {
  99. return dav.monthsAbbreviated[1:]
  100. }
  101. // MonthNarrow returns the locales narrow month given the 'month' provided
  102. func (dav *dav) MonthNarrow(month time.Month) string {
  103. return dav.monthsNarrow[month]
  104. }
  105. // MonthsNarrow returns the locales narrow months
  106. func (dav *dav) MonthsNarrow() []string {
  107. return dav.monthsNarrow[1:]
  108. }
  109. // MonthWide returns the locales wide month given the 'month' provided
  110. func (dav *dav) MonthWide(month time.Month) string {
  111. return dav.monthsWide[month]
  112. }
  113. // MonthsWide returns the locales wide months
  114. func (dav *dav) MonthsWide() []string {
  115. return dav.monthsWide[1:]
  116. }
  117. // WeekdayAbbreviated returns the locales abbreviated weekday given the 'weekday' provided
  118. func (dav *dav) WeekdayAbbreviated(weekday time.Weekday) string {
  119. return dav.daysAbbreviated[weekday]
  120. }
  121. // WeekdaysAbbreviated returns the locales abbreviated weekdays
  122. func (dav *dav) WeekdaysAbbreviated() []string {
  123. return dav.daysAbbreviated
  124. }
  125. // WeekdayNarrow returns the locales narrow weekday given the 'weekday' provided
  126. func (dav *dav) WeekdayNarrow(weekday time.Weekday) string {
  127. return dav.daysNarrow[weekday]
  128. }
  129. // WeekdaysNarrow returns the locales narrow weekdays
  130. func (dav *dav) WeekdaysNarrow() []string {
  131. return dav.daysNarrow
  132. }
  133. // WeekdayShort returns the locales short weekday given the 'weekday' provided
  134. func (dav *dav) WeekdayShort(weekday time.Weekday) string {
  135. return dav.daysShort[weekday]
  136. }
  137. // WeekdaysShort returns the locales short weekdays
  138. func (dav *dav) WeekdaysShort() []string {
  139. return dav.daysShort
  140. }
  141. // WeekdayWide returns the locales wide weekday given the 'weekday' provided
  142. func (dav *dav) WeekdayWide(weekday time.Weekday) string {
  143. return dav.daysWide[weekday]
  144. }
  145. // WeekdaysWide returns the locales wide weekdays
  146. func (dav *dav) WeekdaysWide() []string {
  147. return dav.daysWide
  148. }
  149. // Decimal returns the decimal point of number
  150. func (dav *dav) Decimal() string {
  151. return dav.decimal
  152. }
  153. // Group returns the group of number
  154. func (dav *dav) Group() string {
  155. return dav.group
  156. }
  157. // Group returns the minus sign of number
  158. func (dav *dav) Minus() string {
  159. return dav.minus
  160. }
  161. // FmtNumber returns 'num' with digits/precision of 'v' for 'dav' and handles both Whole and Real numbers based on 'v'
  162. func (dav *dav) FmtNumber(num float64, v uint64) string {
  163. return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
  164. }
  165. // FmtPercent returns 'num' with digits/precision of 'v' for 'dav' and handles both Whole and Real numbers based on 'v'
  166. // NOTE: 'num' passed into FmtPercent is assumed to be in percent already
  167. func (dav *dav) FmtPercent(num float64, v uint64) string {
  168. return strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
  169. }
  170. // FmtCurrency returns the currency representation of 'num' with digits/precision of 'v' for 'dav'
  171. func (dav *dav) FmtCurrency(num float64, v uint64, currency currency.Type) string {
  172. s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
  173. symbol := dav.currencies[currency]
  174. l := len(s) + len(symbol) + 0
  175. count := 0
  176. inWhole := v == 0
  177. b := make([]byte, 0, l)
  178. for i := len(s) - 1; i >= 0; i-- {
  179. if s[i] == '.' {
  180. b = append(b, dav.decimal[0])
  181. inWhole = true
  182. continue
  183. }
  184. if inWhole {
  185. if count == 3 {
  186. b = append(b, dav.group[0])
  187. count = 1
  188. } else {
  189. count++
  190. }
  191. }
  192. b = append(b, s[i])
  193. }
  194. for j := len(symbol) - 1; j >= 0; j-- {
  195. b = append(b, symbol[j])
  196. }
  197. if num < 0 {
  198. b = append(b, dav.minus[0])
  199. }
  200. // reverse
  201. for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
  202. b[i], b[j] = b[j], b[i]
  203. }
  204. if int(v) < 2 {
  205. if v == 0 {
  206. b = append(b, dav.decimal...)
  207. }
  208. for i := 0; i < 2-int(v); i++ {
  209. b = append(b, '0')
  210. }
  211. }
  212. return string(b)
  213. }
  214. // FmtAccounting returns the currency representation of 'num' with digits/precision of 'v' for 'dav'
  215. // in accounting notation.
  216. func (dav *dav) FmtAccounting(num float64, v uint64, currency currency.Type) string {
  217. s := strconv.FormatFloat(math.Abs(num), 'f', int(v), 64)
  218. symbol := dav.currencies[currency]
  219. l := len(s) + len(symbol) + 2
  220. count := 0
  221. inWhole := v == 0
  222. b := make([]byte, 0, l)
  223. for i := len(s) - 1; i >= 0; i-- {
  224. if s[i] == '.' {
  225. b = append(b, dav.decimal[0])
  226. inWhole = true
  227. continue
  228. }
  229. if inWhole {
  230. if count == 3 {
  231. b = append(b, dav.group[0])
  232. count = 1
  233. } else {
  234. count++
  235. }
  236. }
  237. b = append(b, s[i])
  238. }
  239. if num < 0 {
  240. for j := len(symbol) - 1; j >= 0; j-- {
  241. b = append(b, symbol[j])
  242. }
  243. b = append(b, dav.currencyNegativePrefix[0])
  244. } else {
  245. for j := len(symbol) - 1; j >= 0; j-- {
  246. b = append(b, symbol[j])
  247. }
  248. }
  249. // reverse
  250. for i, j := 0, len(b)-1; i < j; i, j = i+1, j-1 {
  251. b[i], b[j] = b[j], b[i]
  252. }
  253. if int(v) < 2 {
  254. if v == 0 {
  255. b = append(b, dav.decimal...)
  256. }
  257. for i := 0; i < 2-int(v); i++ {
  258. b = append(b, '0')
  259. }
  260. }
  261. if num < 0 {
  262. b = append(b, dav.currencyNegativeSuffix...)
  263. }
  264. return string(b)
  265. }
  266. // FmtDateShort returns the short date representation of 't' for 'dav'
  267. func (dav *dav) FmtDateShort(t time.Time) string {
  268. b := make([]byte, 0, 32)
  269. if t.Day() < 10 {
  270. b = append(b, '0')
  271. }
  272. b = strconv.AppendInt(b, int64(t.Day()), 10)
  273. b = append(b, []byte{0x2f}...)
  274. if t.Month() < 10 {
  275. b = append(b, '0')
  276. }
  277. b = strconv.AppendInt(b, int64(t.Month()), 10)
  278. b = append(b, []byte{0x2f}...)
  279. if t.Year() > 0 {
  280. b = strconv.AppendInt(b, int64(t.Year()), 10)
  281. } else {
  282. b = strconv.AppendInt(b, int64(-t.Year()), 10)
  283. }
  284. return string(b)
  285. }
  286. // FmtDateMedium returns the medium date representation of 't' for 'dav'
  287. func (dav *dav) FmtDateMedium(t time.Time) string {
  288. b := make([]byte, 0, 32)
  289. b = strconv.AppendInt(b, int64(t.Day()), 10)
  290. b = append(b, []byte{0x20}...)
  291. b = append(b, dav.monthsAbbreviated[t.Month()]...)
  292. b = append(b, []byte{0x20}...)
  293. if t.Year() > 0 {
  294. b = strconv.AppendInt(b, int64(t.Year()), 10)
  295. } else {
  296. b = strconv.AppendInt(b, int64(-t.Year()), 10)
  297. }
  298. return string(b)
  299. }
  300. // FmtDateLong returns the long date representation of 't' for 'dav'
  301. func (dav *dav) FmtDateLong(t time.Time) string {
  302. b := make([]byte, 0, 32)
  303. b = strconv.AppendInt(b, int64(t.Day()), 10)
  304. b = append(b, []byte{0x20}...)
  305. b = append(b, dav.monthsWide[t.Month()]...)
  306. b = append(b, []byte{0x20}...)
  307. if t.Year() > 0 {
  308. b = strconv.AppendInt(b, int64(t.Year()), 10)
  309. } else {
  310. b = strconv.AppendInt(b, int64(-t.Year()), 10)
  311. }
  312. return string(b)
  313. }
  314. // FmtDateFull returns the full date representation of 't' for 'dav'
  315. func (dav *dav) FmtDateFull(t time.Time) string {
  316. b := make([]byte, 0, 32)
  317. b = append(b, dav.daysWide[t.Weekday()]...)
  318. b = append(b, []byte{0x2c, 0x20}...)
  319. b = strconv.AppendInt(b, int64(t.Day()), 10)
  320. b = append(b, []byte{0x20}...)
  321. b = append(b, dav.monthsWide[t.Month()]...)
  322. b = append(b, []byte{0x20}...)
  323. if t.Year() > 0 {
  324. b = strconv.AppendInt(b, int64(t.Year()), 10)
  325. } else {
  326. b = strconv.AppendInt(b, int64(-t.Year()), 10)
  327. }
  328. return string(b)
  329. }
  330. // FmtTimeShort returns the short time representation of 't' for 'dav'
  331. func (dav *dav) FmtTimeShort(t time.Time) string {
  332. b := make([]byte, 0, 32)
  333. if t.Hour() < 10 {
  334. b = append(b, '0')
  335. }
  336. b = strconv.AppendInt(b, int64(t.Hour()), 10)
  337. b = append(b, dav.timeSeparator...)
  338. if t.Minute() < 10 {
  339. b = append(b, '0')
  340. }
  341. b = strconv.AppendInt(b, int64(t.Minute()), 10)
  342. return string(b)
  343. }
  344. // FmtTimeMedium returns the medium time representation of 't' for 'dav'
  345. func (dav *dav) FmtTimeMedium(t time.Time) string {
  346. b := make([]byte, 0, 32)
  347. if t.Hour() < 10 {
  348. b = append(b, '0')
  349. }
  350. b = strconv.AppendInt(b, int64(t.Hour()), 10)
  351. b = append(b, dav.timeSeparator...)
  352. if t.Minute() < 10 {
  353. b = append(b, '0')
  354. }
  355. b = strconv.AppendInt(b, int64(t.Minute()), 10)
  356. b = append(b, dav.timeSeparator...)
  357. if t.Second() < 10 {
  358. b = append(b, '0')
  359. }
  360. b = strconv.AppendInt(b, int64(t.Second()), 10)
  361. return string(b)
  362. }
  363. // FmtTimeLong returns the long time representation of 't' for 'dav'
  364. func (dav *dav) FmtTimeLong(t time.Time) string {
  365. b := make([]byte, 0, 32)
  366. if t.Hour() < 10 {
  367. b = append(b, '0')
  368. }
  369. b = strconv.AppendInt(b, int64(t.Hour()), 10)
  370. b = append(b, dav.timeSeparator...)
  371. if t.Minute() < 10 {
  372. b = append(b, '0')
  373. }
  374. b = strconv.AppendInt(b, int64(t.Minute()), 10)
  375. b = append(b, dav.timeSeparator...)
  376. if t.Second() < 10 {
  377. b = append(b, '0')
  378. }
  379. b = strconv.AppendInt(b, int64(t.Second()), 10)
  380. b = append(b, []byte{0x20}...)
  381. tz, _ := t.Zone()
  382. b = append(b, tz...)
  383. return string(b)
  384. }
  385. // FmtTimeFull returns the full time representation of 't' for 'dav'
  386. func (dav *dav) FmtTimeFull(t time.Time) string {
  387. b := make([]byte, 0, 32)
  388. if t.Hour() < 10 {
  389. b = append(b, '0')
  390. }
  391. b = strconv.AppendInt(b, int64(t.Hour()), 10)
  392. b = append(b, dav.timeSeparator...)
  393. if t.Minute() < 10 {
  394. b = append(b, '0')
  395. }
  396. b = strconv.AppendInt(b, int64(t.Minute()), 10)
  397. b = append(b, dav.timeSeparator...)
  398. if t.Second() < 10 {
  399. b = append(b, '0')
  400. }
  401. b = strconv.AppendInt(b, int64(t.Second()), 10)
  402. b = append(b, []byte{0x20}...)
  403. tz, _ := t.Zone()
  404. if btz, ok := dav.timezones[tz]; ok {
  405. b = append(b, btz...)
  406. } else {
  407. b = append(b, tz...)
  408. }
  409. return string(b)
  410. }