]\n\t2018.04.18: mv.Xml/mv.XmlIndent encodes non-map[string]interface{} map values - map[string]string, map[int]uint, etc.\n\t2018.03.29: mv.Gob/NewMapGob support gob encoding/decoding of Maps.\n\t2018.03.26: Added mxj/x2j-wrapper sub-package for migrating from legacy x2j package.\n\t2017.02.22: LeafNode paths can use \".N\" syntax rather than \"[N]\" for list member indexing.\n\t2017.02.10: SetFieldSeparator changes field separator for args in UpdateValuesForPath, ValuesFor... methods.\n\t2017.02.06: Support XMPP stream processing - HandleXMPPStreamTag().\n\t2016.11.07: Preserve name space prefix syntax in XmlSeq parser - NewMapXmlSeq(), etc.\n\t2016.06.25: Support overriding default XML attribute prefix, \"-\", in Map keys - SetAttrPrefix().\n\t2016.05.26: Support customization of xml.Decoder by exposing CustomDecoder variable.\n\t2016.03.19: Escape invalid chars when encoding XML attribute and element values - XMLEscapeChars().\n\t2016.03.02: By default decoding XML with float64 and bool value casting will not cast \"NaN\", \"Inf\", and \"-Inf\".\n\t To cast them to float64, first set flag with CastNanInf(true).\n\t2016.02.22: New mv.Root(), mv.Elements(), mv.Attributes methods let you examine XML document structure.\n\t2016.02.16: Add CoerceKeysToLower() option to handle tags with mixed capitalization.\n\t2016.02.12: Seek for first xml.StartElement token; only return error if io.EOF is reached first (handles BOM).\n\t2015.12.02: XML decoding/encoding that preserves original structure of document. See NewMapXmlSeq()\n\t and mv.XmlSeq() / mv.XmlSeqIndent().\n\t2015-05-20: New: mv.StringIndentNoTypeInfo().\n\t Also, alphabetically sort map[string]interface{} values by key to prettify output for mv.Xml(),\n\t mv.XmlIndent(), mv.StringIndent(), mv.StringIndentNoTypeInfo().\n\t2014-11-09: IncludeTagSeqNum() adds \"_seq\" key with XML doc positional information.\n\t (NOTE: PreserveXmlList() is similar and will be here soon.)\n\t2014-09-18: inspired by NYTimes fork, added PrependAttrWithHyphen() to allow stripping hyphen from attribute tag.\n\t2014-08-02: AnyXml() and AnyXmlIndent() will try to marshal arbitrary values to XML.\n\t2014-04-28: ValuesForPath() and NewMap() now accept path with indexed array references.\n\nBasic Unmarshal XML to map[string]interface{}
\ntype Map map[string]interface{}\n\nCreate a `Map` value, 'mv', from any `map[string]interface{}` value, 'v':\nmv := Map(v)
\n\nUnmarshal / marshal XML as a `Map` value, 'mv':\nmv, err := NewMapXml(xmlValue) // unmarshal\nxmlValue, err := mv.Xml() // marshal
\n\nUnmarshal XML from an `io.Reader` as a `Map` value, 'mv':\nmv, err := NewMapXmlReader(xmlReader) // repeated calls, as with an os.File Reader, will process stream\nmv, raw, err := NewMapXmlReaderRaw(xmlReader) // 'raw' is the raw XML that was decoded
\n\nMarshal `Map` value, 'mv', to an XML Writer (`io.Writer`):\nerr := mv.XmlWriter(xmlWriter)\nraw, err := mv.XmlWriterRaw(xmlWriter) // 'raw' is the raw XML that was written on xmlWriter
\n \nAlso, for prettified output:\nxmlValue, err := mv.XmlIndent(prefix, indent, ...)\nerr := mv.XmlIndentWriter(xmlWriter, prefix, indent, ...)\nraw, err := mv.XmlIndentWriterRaw(xmlWriter, prefix, indent, ...)
\n\nBulk process XML with error handling (note: handlers must return a boolean value):\nerr := HandleXmlReader(xmlReader, mapHandler(Map), errHandler(error))\nerr := HandleXmlReaderRaw(xmlReader, mapHandler(Map, []byte), errHandler(error, []byte))
\n\nConverting XML to JSON: see Examples for `NewMapXml` and `HandleXmlReader`.\n\nThere are comparable functions and methods for JSON processing.\n\nArbitrary structure values can be decoded to / encoded from `Map` values:\nmv, err := NewMapStruct(structVal)\nerr := mv.Struct(structPointer)
\n\nExtract / modify Map values
\nTo work with XML tag values, JSON or Map key values or structure field values, decode the XML, JSON\nor structure to a `Map` value, 'mv', or cast a `map[string]interface{}` value to a `Map` value, 'mv', then:\npaths := mv.PathsForKey(key)\npath := mv.PathForKeyShortest(key)\nvalues, err := mv.ValuesForKey(key, subkeys)\nvalues, err := mv.ValuesForPath(path, subkeys)\ncount, err := mv.UpdateValuesForPath(newVal, path, subkeys)
\n\nGet everything at once, irrespective of path depth:\nleafnodes := mv.LeafNodes()\nleafvalues := mv.LeafValues()
\n\nA new `Map` with whatever keys are desired can be created from the current `Map` and then encoded in XML\nor JSON. (Note: keys can use dot-notation.)\nnewMap, err := mv.NewMap(\"oldKey_1:newKey_1\", \"oldKey_2:newKey_2\", ..., \"oldKey_N:newKey_N\")\nnewMap, err := mv.NewMap(\"oldKey1\", \"oldKey3\", \"oldKey5\") // a subset of 'mv'; see \"examples/partial.go\"\nnewXml, err := newMap.Xml() // for example\nnewJson, err := newMap.Json() // ditto
\n\nUsage
\n\nThe package is fairly well [self-documented with examples](http://godoc.org/github.com/clbanning/mxj).\n\nAlso, the subdirectory \"examples\" contains a wide range of examples, several taken from golang-nuts discussions.\n\nXML parsing conventions
\n\nUsing NewMapXml()\n\n - Attributes are parsed to `map[string]interface{}` values by prefixing a hyphen, `-`,\n to the attribute label. (Unless overridden by `PrependAttrWithHyphen(false)` or\n `SetAttrPrefix()`.)\n - If the element is a simple element and has attributes, the element value\n is given the key `#text` for its `map[string]interface{}` representation. (See\n the 'atomFeedString.xml' test data, below.)\n - XML comments, directives, and process instructions are ignored.\n - If CoerceKeysToLower() has been called, then the resultant keys will be lower case.\n\nUsing NewMapXmlSeq()\n\n - Attributes are parsed to `map[\"#attr\"]map[]map[string]interface{}`values\n where the `` value has \"#text\" and \"#seq\" keys - the \"#text\" key holds the \n value for ``.\n - All elements, except for the root, have a \"#seq\" key.\n - Comments, directives, and process instructions are unmarshalled into the Map using the\n keys \"#comment\", \"#directive\", and \"#procinst\", respectively. (See documentation for more\n specifics.)\n - Name space syntax is preserved: \n - `something` parses to `map[\"ns:key\"]interface{}{\"something\"}`\n - `xmlns:ns=\"http://myns.com/ns\"` parses to `map[\"xmlns:ns\"]interface{}{\"http://myns.com/ns\"}`\n\nBoth\n\n - By default, \"Nan\", \"Inf\", and \"-Inf\" values are not cast to float64. If you want them\n to be cast, set a flag to cast them using CastNanInf(true).\n\nXML encoding conventions
\n\n - 'nil' `Map` values, which may represent 'null' JSON values, are encoded as ``.\n NOTE: the operation is not symmetric as `` elements are decoded as `tag:\"\"` `Map` values,\n which, then, encode in JSON as `\"tag\":\"\"` values.\n - ALSO: there is no guarantee that the encoded XML doc will be the same as the decoded one. (Go\n randomizes the walk through map[string]interface{} values.) If you plan to re-encode the\n Map value to XML and want the same sequencing of elements look at NewMapXmlSeq() and\n mv.XmlSeq() - these try to preserve the element sequencing but with added complexity when\n working with the Map representation.\n\nRunning \"go test\"
\n\nBecause there are no guarantees on the sequence map elements are retrieved, the tests have been \nwritten for visual verification in most cases. One advantage is that you can easily use the \noutput from running \"go test\" as examples of calling the various functions and methods.\n\nMotivation
\n\nI make extensive use of JSON for messaging and typically unmarshal the messages into\n`map[string]interface{}` values. This is easily done using `json.Unmarshal` from the\nstandard Go libraries. Unfortunately, many legacy solutions use structured\nXML messages; in those environments the applications would have to be refactored to\ninteroperate with my components.\n\nThe better solution is to just provide an alternative HTTP handler that receives\nXML messages and parses it into a `map[string]interface{}` value and then reuse\nall the JSON-based code. The Go `xml.Unmarshal()` function does not provide the same\noption of unmarshaling XML messages into `map[string]interface{}` values. So I wrote\na couple of small functions to fill this gap and released them as the x2j package.\n\nOver the next year and a half additional features were added, and the companion j2x\npackage was released to address XML encoding of arbitrary JSON and `map[string]interface{}`\nvalues. As part of a refactoring of our production system and looking at how we had been\nusing the x2j and j2x packages we found that we rarely performed direct XML-to-JSON or\nJSON-to_XML conversion and that working with the XML or JSON as `map[string]interface{}`\nvalues was the primary value. Thus, everything was refactored into the mxj package.\n\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/remove.go",
"content": "package mxj\n\nimport \"strings\"\n\n// Removes the path.\nfunc (mv Map) Remove(path string) error {\n\tm := map[string]interface{}(mv)\n\treturn remove(m, path)\n}\n\nfunc remove(m interface{}, path string) error {\n\tval, err := prevValueByPath(m, path)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tlastKey := lastKey(path)\n\tdelete(val, lastKey)\n\n\treturn nil\n}\n\n// returns the last key of the path.\n// lastKey(\"a.b.c\") would had returned \"c\"\nfunc lastKey(path string) string {\n\tkeys := strings.Split(path, \".\")\n\tkey := keys[len(keys)-1]\n\treturn key\n}\n\n// returns the path without the last key\n// parentPath(\"a.b.c\") whould had returned \"a.b\"\nfunc parentPath(path string) string {\n\tkeys := strings.Split(path, \".\")\n\tparentPath := strings.Join(keys[0:len(keys)-1], \".\")\n\treturn parentPath\n}\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/rename.go",
"content": "package mxj\n\nimport (\n\t\"errors\"\n\t\"strings\"\n)\n\n// RenameKey renames a key in a Map.\n// It works only for nested maps. \n// It doesn't work for cases when the key is in a list.\nfunc (mv Map) RenameKey(path string, newName string) error {\n\tvar v bool\n\tvar err error\n\tif v, err = mv.Exists(path); err == nil && !v {\n\t\treturn errors.New(\"RenameKey: path not found: \" + path)\n\t} else if err != nil {\n\t\treturn err\n\t}\n\tif v, err = mv.Exists(parentPath(path) + \".\" + newName); err == nil && v {\n\t\treturn errors.New(\"RenameKey: key already exists: \" + newName)\n\t} else if err != nil {\n\t\treturn err\n\t}\n\n\tm := map[string]interface{}(mv)\n\treturn renameKey(m, path, newName)\n}\n\nfunc renameKey(m interface{}, path string, newName string) error {\n\tval, err := prevValueByPath(m, path)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\toldName := lastKey(path)\n\tval[newName] = val[oldName]\n\tdelete(val, oldName)\n\n\treturn nil\n}\n\n// returns a value which contains a last key in the path\n// For example: prevValueByPath(\"a.b.c\", {a{b{c: 3}}}) returns {c: 3}\nfunc prevValueByPath(m interface{}, path string) (map[string]interface{}, error) {\n\tkeys := strings.Split(path, \".\")\n\n\tswitch mValue := m.(type) {\n\tcase map[string]interface{}:\n\t\tfor key, value := range mValue {\n\t\t\tif key == keys[0] {\n\t\t\t\tif len(keys) == 1 {\n\t\t\t\t\treturn mValue, nil\n\t\t\t\t} else {\n\t\t\t\t\t// keep looking for the full path to the key\n\t\t\t\t\treturn prevValueByPath(value, strings.Join(keys[1:], \".\"))\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn nil, errors.New(\"prevValueByPath: didn't find path – \" + path)\n}\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/set.go",
"content": "package mxj\n\nimport (\n\t\"strings\"\n)\n\n// Sets the value for the path\nfunc (mv Map) SetValueForPath(value interface{}, path string) error {\n\tpathAry := strings.Split(path, \".\")\n\tparentPathAry := pathAry[0 : len(pathAry)-1]\n\tparentPath := strings.Join(parentPathAry, \".\")\n\n\tval, err := mv.ValueForPath(parentPath)\n\tif err != nil {\n\t\treturn err\n\t}\n\tif val == nil {\n\t\treturn nil // we just ignore the request if there's no val\n\t}\n\n\tkey := pathAry[len(pathAry)-1]\n\tcVal := val.(map[string]interface{})\n\tcVal[key] = value\n\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/setfieldsep.go",
"content": "package mxj\n\n// Per: https://github.com/clbanning/mxj/issues/37#issuecomment-278651862\nvar fieldSep string = \":\"\n\n// SetFieldSeparator changes the default field separator, \":\", for the\n// newVal argument in mv.UpdateValuesForPath and the optional 'subkey' arguments\n// in mv.ValuesForKey and mv.ValuesForPath. \n// \n// E.g., if the newVal value is \"http://blah/blah\", setting the field separator\n// to \"|\" will allow the newVal specification, \"|http://blah/blah\" to parse\n// properly. If called with no argument or an empty string value, the field\n// separator is set to the default, \":\".\nfunc SetFieldSeparator(s ...string) {\n\tif len(s) == 0 || s[0] == \"\" {\n\t\tfieldSep = \":\" // the default\n\t\treturn\n\t}\n\tfieldSep = s[0]\n}\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/songtext.xml",
"content": "\n\thelp me!\n\t\n\t\t\n\t\t\t\n\t\t\t\tHenry was a renegade\n\t\t\t\tDidn't like to play it safe\n\t\t\t\tOne component at a time\n\t\t\t\tThere's got to be a better way\n\t\t\t\tOh, people came from miles around\n\t\t\t\tSearching for a steady job\n\t\t\t\tWelcome to the Motor Town\n\t\t\t\tBooming like an atom bomb\n\t\t\t\n\t\t\t\n\t\t\t\tOh, Henry was the end of the story\n\t\t\t\tThen everything went wrong\n\t\t\t\tAnd we'll return it to its former glory\n\t\t\t\tBut it just takes so long\n\t\t\t\n\t\t\n\t\t\n\t\t\tIt's going to take a long time\n\t\t\tIt's going to take it, but we'll make it one day\n\t\t\tIt's going to take a long time\n\t\t\tIt's going to take it, but we'll make it one day\n\t\t\n\t\n\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/strict.go",
"content": "// Copyright 2016 Charles Banning. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file\n\n// strict.go actually addresses setting xml.Decoder attribute\n// values. This'll let you parse non-standard XML.\n\npackage mxj\n\nimport (\n\t\"encoding/xml\"\n)\n\n// CustomDecoder can be used to specify xml.Decoder attribute\n// values, e.g., Strict:false, to be used. By default CustomDecoder\n// is nil. If CustomeDecoder != nil, then mxj.XmlCharsetReader variable is\n// ignored and must be set as part of the CustomDecoder value, if needed.\n//\tUsage:\n//\t\tmxj.CustomDecoder = &xml.Decoder{Strict:false}\nvar CustomDecoder *xml.Decoder\n\n// useCustomDecoder copy over public attributes from customDecoder\nfunc useCustomDecoder(d *xml.Decoder) {\n\td.Strict = CustomDecoder.Strict\n\td.AutoClose = CustomDecoder.AutoClose\n\td.Entity = CustomDecoder.Entity\n\td.CharsetReader = CustomDecoder.CharsetReader\n\td.DefaultSpace = CustomDecoder.DefaultSpace\n}\n\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/struct.go",
"content": "// Copyright 2012-2017 Charles Banning. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file\n\npackage mxj\n\nimport (\n\t\"encoding/json\"\n\t\"errors\"\n\t\"reflect\"\n\n\t// \"github.com/fatih/structs\"\n)\n\n// Create a new Map value from a structure. Error returned if argument is not a structure.\n// Only public structure fields are decoded in the Map value. See github.com/fatih/structs#Map\n// for handling of \"structs\" tags.\n\n// DEPRECATED - import github.com/fatih/structs and cast result of structs.Map to mxj.Map.\n//\timport \"github.com/fatih/structs\"\n//\t...\n//\t sm, err := structs.Map()\n//\t if err != nil {\n//\t // handle error\n//\t }\n//\t m := mxj.Map(sm)\n// Alernatively uncomment the old source and import in struct.go.\nfunc NewMapStruct(structVal interface{}) (Map, error) {\n\treturn nil, errors.New(\"deprecated - see package documentation\")\n\t/*\n\t\tif !structs.IsStruct(structVal) {\n\t\t\treturn nil, errors.New(\"NewMapStruct() error: argument is not type Struct\")\n\t\t}\n\t\treturn structs.Map(structVal), nil\n\t*/\n}\n\n// Marshal a map[string]interface{} into a structure referenced by 'structPtr'. Error returned\n// if argument is not a pointer or if json.Unmarshal returns an error.\n//\tjson.Unmarshal structure encoding rules are followed to encode public structure fields.\nfunc (mv Map) Struct(structPtr interface{}) error {\n\t// should check that we're getting a pointer.\n\tif reflect.ValueOf(structPtr).Kind() != reflect.Ptr {\n\t\treturn errors.New(\"mv.Struct() error: argument is not type Ptr\")\n\t}\n\n\tm := map[string]interface{}(mv)\n\tj, err := json.Marshal(m)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\treturn json.Unmarshal(j, structPtr)\n}\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/updatevalues.go",
"content": "// Copyright 2012-2014, 2017 Charles Banning. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file\n\n// updatevalues.go - modify a value based on path and possibly sub-keys\n// TODO(clb): handle simple elements with attributes and NewMapXmlSeq Map values.\n\npackage mxj\n\nimport (\n\t\"fmt\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// Update value based on path and possible sub-key values.\n// A count of the number of values changed and any error are returned.\n// If the count == 0, then no path (and subkeys) matched.\n//\t'newVal' can be a Map or map[string]interface{} value with a single 'key' that is the key to be modified\n//\t or a string value \"key:value[:type]\" where type is \"bool\" or \"num\" to cast the value.\n//\t'path' is dot-notation list of keys to traverse; last key in path can be newVal key\n//\t NOTE: 'path' spec does not currently support indexed array references.\n//\t'subkeys' are \"key:value[:type]\" entries that must match for path node\n// - For attributes prefix the label with the attribute prefix character, by default a \n// hyphen, '-', e.g., \"-seq:3\". (See SetAttrPrefix function.)\n// - The subkey can be wildcarded - \"key:*\" - to require that it's there with some value.\n// - If a subkey is preceeded with the '!' character, the key:value[:type] entry is treated as an\n//\t exclusion critera - e.g., \"!author:William T. Gaddis\".\n//\n//\tNOTES:\n//\t\t1. Simple elements with attributes need a path terminated as \".#text\" to modify the actual value.\n//\t\t2. Values in Maps created using NewMapXmlSeq are map[string]interface{} values with a \"#text\" key.\n//\t\t3. If values in 'newVal' or 'subkeys' args contain \":\", use SetFieldSeparator to an unused symbol,\n//\t perhaps \"|\".\nfunc (mv Map) UpdateValuesForPath(newVal interface{}, path string, subkeys ...string) (int, error) {\n\tm := map[string]interface{}(mv)\n\n\t// extract the subkeys\n\tvar subKeyMap map[string]interface{}\n\tif len(subkeys) > 0 {\n\t\tvar err error\n\t\tsubKeyMap, err = getSubKeyMap(subkeys...)\n\t\tif err != nil {\n\t\t\treturn 0, err\n\t\t}\n\t}\n\n\t// extract key and value from newVal\n\tvar key string\n\tvar val interface{}\n\tswitch newVal.(type) {\n\tcase map[string]interface{}, Map:\n\t\tswitch newVal.(type) { // \"fallthrough is not permitted in type switch\" (Spec)\n\t\tcase Map:\n\t\t\tnewVal = newVal.(Map).Old()\n\t\t}\n\t\tif len(newVal.(map[string]interface{})) != 1 {\n\t\t\treturn 0, fmt.Errorf(\"newVal map can only have len == 1 - %+v\", newVal)\n\t\t}\n\t\tfor key, val = range newVal.(map[string]interface{}) {\n\t\t}\n\tcase string: // split it as a key:value pair\n\t\tss := strings.Split(newVal.(string), fieldSep)\n\t\tn := len(ss)\n\t\tif n < 2 || n > 3 {\n\t\t\treturn 0, fmt.Errorf(\"unknown newVal spec - %+v\", newVal)\n\t\t}\n\t\tkey = ss[0]\n\t\tif n == 2 {\n\t\t\tval = interface{}(ss[1])\n\t\t} else if n == 3 {\n\t\t\tswitch ss[2] {\n\t\t\tcase \"bool\", \"boolean\":\n\t\t\t\tnv, err := strconv.ParseBool(ss[1])\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn 0, fmt.Errorf(\"can't convert newVal to bool - %+v\", newVal)\n\t\t\t\t}\n\t\t\t\tval = interface{}(nv)\n\t\t\tcase \"num\", \"numeric\", \"float\", \"int\":\n\t\t\t\tnv, err := strconv.ParseFloat(ss[1], 64)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn 0, fmt.Errorf(\"can't convert newVal to float64 - %+v\", newVal)\n\t\t\t\t}\n\t\t\t\tval = interface{}(nv)\n\t\t\tdefault:\n\t\t\t\treturn 0, fmt.Errorf(\"unknown type for newVal value - %+v\", newVal)\n\t\t\t}\n\t\t}\n\tdefault:\n\t\treturn 0, fmt.Errorf(\"invalid newVal type - %+v\", newVal)\n\t}\n\n\t// parse path\n\tkeys := strings.Split(path, \".\")\n\n\tvar count int\n\tupdateValuesForKeyPath(key, val, m, keys, subKeyMap, &count)\n\n\treturn count, nil\n}\n\n// navigate the path\nfunc updateValuesForKeyPath(key string, value interface{}, m interface{}, keys []string, subkeys map[string]interface{}, cnt *int) {\n\t// ----- at end node: looking at possible node to get 'key' ----\n\tif len(keys) == 1 {\n\t\tupdateValue(key, value, m, keys[0], subkeys, cnt)\n\t\treturn\n\t}\n\n\t// ----- here we are navigating the path thru the penultimate node --------\n\t// key of interest is keys[0] - the next in the path\n\tswitch keys[0] {\n\tcase \"*\": // wildcard - scan all values\n\t\tswitch m.(type) {\n\t\tcase map[string]interface{}:\n\t\t\tfor _, v := range m.(map[string]interface{}) {\n\t\t\t\tupdateValuesForKeyPath(key, value, v, keys[1:], subkeys, cnt)\n\t\t\t}\n\t\tcase []interface{}:\n\t\t\tfor _, v := range m.([]interface{}) {\n\t\t\t\tswitch v.(type) {\n\t\t\t\t// flatten out a list of maps - keys are processed\n\t\t\t\tcase map[string]interface{}:\n\t\t\t\t\tfor _, vv := range v.(map[string]interface{}) {\n\t\t\t\t\t\tupdateValuesForKeyPath(key, value, vv, keys[1:], subkeys, cnt)\n\t\t\t\t\t}\n\t\t\t\tdefault:\n\t\t\t\t\tupdateValuesForKeyPath(key, value, v, keys[1:], subkeys, cnt)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\tdefault: // key - must be map[string]interface{}\n\t\tswitch m.(type) {\n\t\tcase map[string]interface{}:\n\t\t\tif v, ok := m.(map[string]interface{})[keys[0]]; ok {\n\t\t\t\tupdateValuesForKeyPath(key, value, v, keys[1:], subkeys, cnt)\n\t\t\t}\n\t\tcase []interface{}: // may be buried in list\n\t\t\tfor _, v := range m.([]interface{}) {\n\t\t\t\tswitch v.(type) {\n\t\t\t\tcase map[string]interface{}:\n\t\t\t\t\tif vv, ok := v.(map[string]interface{})[keys[0]]; ok {\n\t\t\t\t\t\tupdateValuesForKeyPath(key, value, vv, keys[1:], subkeys, cnt)\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n// change value if key and subkeys are present\nfunc updateValue(key string, value interface{}, m interface{}, keys0 string, subkeys map[string]interface{}, cnt *int) {\n\t// there are two possible options for the value of 'keys0': map[string]interface, []interface{}\n\t// and 'key' is a key in the map or is a key in a map in a list.\n\tswitch m.(type) {\n\tcase map[string]interface{}: // gotta have the last key\n\t\tif keys0 == \"*\" {\n\t\t\tfor k := range m.(map[string]interface{}) {\n\t\t\t\tupdateValue(key, value, m, k, subkeys, cnt)\n\t\t\t}\n\t\t\treturn\n\t\t}\n\t\tendVal, _ := m.(map[string]interface{})[keys0]\n\n\t\t// if newV key is the end of path, replace the value for path-end\n\t\t// may be []interface{} - means replace just an entry w/ subkeys\n\t\t// otherwise replace the keys0 value if subkeys are there\n\t\t// NOTE: this will replace the subkeys, also\n\t\tif key == keys0 {\n\t\t\tswitch endVal.(type) {\n\t\t\tcase map[string]interface{}:\n\t\t\t\tif hasSubKeys(m, subkeys) {\n\t\t\t\t\t(m.(map[string]interface{}))[keys0] = value\n\t\t\t\t\t(*cnt)++\n\t\t\t\t}\n\t\t\tcase []interface{}:\n\t\t\t\t// without subkeys can't select list member to modify\n\t\t\t\t// so key:value spec is it ...\n\t\t\t\tif hasSubKeys(m, subkeys) {\n\t\t\t\t\t(m.(map[string]interface{}))[keys0] = value\n\t\t\t\t\t(*cnt)++\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t\tnv := make([]interface{}, 0)\n\t\t\t\tvar valmodified bool\n\t\t\t\tfor _, v := range endVal.([]interface{}) {\n\t\t\t\t\t// check entry subkeys\n\t\t\t\t\tif hasSubKeys(v, subkeys) {\n\t\t\t\t\t\t// replace v with value\n\t\t\t\t\t\tnv = append(nv, value)\n\t\t\t\t\t\tvalmodified = true\n\t\t\t\t\t\t(*cnt)++\n\t\t\t\t\t\tcontinue\n\t\t\t\t\t}\n\t\t\t\t\tnv = append(nv, v)\n\t\t\t\t}\n\t\t\t\tif valmodified {\n\t\t\t\t\t(m.(map[string]interface{}))[keys0] = interface{}(nv)\n\t\t\t\t}\n\t\t\tdefault: // anything else is a strict replacement\n\t\t\t\tif hasSubKeys(m, subkeys) {\n\t\t\t\t\t(m.(map[string]interface{}))[keys0] = value\n\t\t\t\t\t(*cnt)++\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn\n\t\t}\n\n\t\t// so value is for an element of endVal\n\t\t// if endVal is a map then 'key' must be there w/ subkeys\n\t\t// if endVal is a list then 'key' must be in a list member w/ subkeys\n\t\tswitch endVal.(type) {\n\t\tcase map[string]interface{}:\n\t\t\tif !hasSubKeys(endVal, subkeys) {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tif _, ok := (endVal.(map[string]interface{}))[key]; ok {\n\t\t\t\t(endVal.(map[string]interface{}))[key] = value\n\t\t\t\t(*cnt)++\n\t\t\t}\n\t\tcase []interface{}: // keys0 points to a list, check subkeys\n\t\t\tfor _, v := range endVal.([]interface{}) {\n\t\t\t\t// got to be a map so we can replace value for 'key'\n\t\t\t\tvv, vok := v.(map[string]interface{})\n\t\t\t\tif !vok {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tif _, ok := vv[key]; !ok {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tif !hasSubKeys(vv, subkeys) {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tvv[key] = value\n\t\t\t\t(*cnt)++\n\t\t\t}\n\t\t}\n\tcase []interface{}: // key may be in a list member\n\t\t// don't need to handle keys0 == \"*\"; we're looking at everything, anyway.\n\t\tfor _, v := range m.([]interface{}) {\n\t\t\t// only map values - we're looking for 'key'\n\t\t\tmm, ok := v.(map[string]interface{})\n\t\t\tif !ok {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif _, ok := mm[key]; !ok {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif !hasSubKeys(mm, subkeys) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tmm[key] = value\n\t\t\t(*cnt)++\n\t\t}\n\t}\n\n\t// return\n}\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/xml.go",
"content": "// Copyright 2012-2016, 2018-2019 Charles Banning. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file\n\n// xml.go - basically the core of X2j for map[string]interface{} values.\n// NewMapXml, NewMapXmlReader, mv.Xml, mv.XmlWriter\n// see x2j and j2x for wrappers to provide end-to-end transformation of XML and JSON messages.\n\npackage mxj\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"encoding/xml\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"reflect\"\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n\t\"time\"\n)\n\nvar (\n\ttextK = \"#text\"\n\tseqK = \"#seq\"\n\tcommentK = \"#comment\"\n\tattrK = \"#attr\"\n\tdirectiveK = \"#directive\"\n\tprocinstK = \"#procinst\"\n\ttargetK = \"#target\"\n\tinstK = \"#inst\"\n)\n\n// Support overriding default Map keys prefix\n\nfunc SetGlobalKeyMapPrefix(s string) {\n\ttextK = strings.ReplaceAll(textK, textK[0:1], s)\n\tseqK = strings.ReplaceAll(seqK, seqK[0:1], s)\n\tcommentK = strings.ReplaceAll(commentK, commentK[0:1], s)\n\tdirectiveK = strings.ReplaceAll(directiveK, directiveK[0:1], s)\n\tprocinstK = strings.ReplaceAll(procinstK, procinstK[0:1], s)\n\ttargetK = strings.ReplaceAll(targetK, targetK[0:1], s)\n\tinstK = strings.ReplaceAll(instK, instK[0:1], s)\n\tattrK = strings.ReplaceAll(attrK, attrK[0:1], s)\n}\n\n// ------------------- NewMapXml & NewMapXmlReader ... -------------------------\n\n// If XmlCharsetReader != nil, it will be used to decode the XML, if required.\n// Note: if CustomDecoder != nil, then XmlCharsetReader is ignored;\n// set the CustomDecoder attribute instead.\n// import (\n//\t charset \"code.google.com/p/go-charset/charset\"\n//\t github.com/clbanning/mxj\n//\t )\n// ...\n// mxj.XmlCharsetReader = charset.NewReader\n// m, merr := mxj.NewMapXml(xmlValue)\nvar XmlCharsetReader func(charset string, input io.Reader) (io.Reader, error)\n\n// NewMapXml - convert a XML doc into a Map\n// (This is analogous to unmarshalling a JSON string to map[string]interface{} using json.Unmarshal().)\n//\tIf the optional argument 'cast' is 'true', then values will be converted to boolean or float64 if possible.\n//\n//\tConverting XML to JSON is a simple as:\n//\t\t...\n//\t\tmapVal, merr := mxj.NewMapXml(xmlVal)\n//\t\tif merr != nil {\n//\t\t\t// handle error\n//\t\t}\n//\t\tjsonVal, jerr := mapVal.Json()\n//\t\tif jerr != nil {\n//\t\t\t// handle error\n//\t\t}\n//\n//\tNOTES:\n//\t 1. Declarations, directives, process instructions and comments are NOT parsed.\n//\t 2. The 'xmlVal' will be parsed looking for an xml.StartElement, so BOM and other\n//\t extraneous xml.CharData will be ignored unless io.EOF is reached first.\n//\t 3. If CoerceKeysToLower() has been called, then all key values will be lower case.\n//\t 4. If CoerceKeysToSnakeCase() has been called, then all key values will be converted to snake case.\n//\t 5. If DisableTrimWhiteSpace(b bool) has been called, then all values will be trimmed or not. 'true' by default.\nfunc NewMapXml(xmlVal []byte, cast ...bool) (Map, error) {\n\tvar r bool\n\tif len(cast) == 1 {\n\t\tr = cast[0]\n\t}\n\treturn xmlToMap(xmlVal, r)\n}\n\n// Get next XML doc from an io.Reader as a Map value. Returns Map value.\n//\tNOTES:\n//\t 1. Declarations, directives, process instructions and comments are NOT parsed.\n//\t 2. The 'xmlReader' will be parsed looking for an xml.StartElement, so BOM and other\n//\t extraneous xml.CharData will be ignored unless io.EOF is reached first.\n//\t 3. If CoerceKeysToLower() has been called, then all key values will be lower case.\n//\t 4. If CoerceKeysToSnakeCase() has been called, then all key values will be converted to snake case.\nfunc NewMapXmlReader(xmlReader io.Reader, cast ...bool) (Map, error) {\n\tvar r bool\n\tif len(cast) == 1 {\n\t\tr = cast[0]\n\t}\n\n\t// We need to put an *os.File reader in a ByteReader or the xml.NewDecoder\n\t// will wrap it in a bufio.Reader and seek on the file beyond where the\n\t// xml.Decoder parses!\n\tif _, ok := xmlReader.(io.ByteReader); !ok {\n\t\txmlReader = myByteReader(xmlReader) // see code at EOF\n\t}\n\n\t// build the map\n\treturn xmlReaderToMap(xmlReader, r)\n}\n\n// Get next XML doc from an io.Reader as a Map value. Returns Map value and slice with the raw XML.\n//\tNOTES:\n//\t 1. Declarations, directives, process instructions and comments are NOT parsed.\n//\t 2. Due to the implementation of xml.Decoder, the raw XML off the reader is buffered to []byte\n//\t using a ByteReader. If the io.Reader is an os.File, there may be significant performance impact.\n//\t See the examples - getmetrics1.go through getmetrics4.go - for comparative use cases on a large\n//\t data set. If the io.Reader is wrapping a []byte value in-memory, however, such as http.Request.Body\n//\t you CAN use it to efficiently unmarshal a XML doc and retrieve the raw XML in a single call.\n//\t 3. The 'raw' return value may be larger than the XML text value.\n//\t 4. The 'xmlReader' will be parsed looking for an xml.StartElement, so BOM and other\n//\t extraneous xml.CharData will be ignored unless io.EOF is reached first.\n//\t 5. If CoerceKeysToLower() has been called, then all key values will be lower case.\n//\t 6. If CoerceKeysToSnakeCase() has been called, then all key values will be converted to snake case.\nfunc NewMapXmlReaderRaw(xmlReader io.Reader, cast ...bool) (Map, []byte, error) {\n\tvar r bool\n\tif len(cast) == 1 {\n\t\tr = cast[0]\n\t}\n\t// create TeeReader so we can retrieve raw XML\n\tbuf := make([]byte, 0)\n\twb := bytes.NewBuffer(buf)\n\ttrdr := myTeeReader(xmlReader, wb) // see code at EOF\n\n\tm, err := xmlReaderToMap(trdr, r)\n\n\t// retrieve the raw XML that was decoded\n\tb := wb.Bytes()\n\n\tif err != nil {\n\t\treturn nil, b, err\n\t}\n\n\treturn m, b, nil\n}\n\n// xmlReaderToMap() - parse a XML io.Reader to a map[string]interface{} value\nfunc xmlReaderToMap(rdr io.Reader, r bool) (map[string]interface{}, error) {\n\t// parse the Reader\n\tp := xml.NewDecoder(rdr)\n\tif CustomDecoder != nil {\n\t\tuseCustomDecoder(p)\n\t} else {\n\t\tp.CharsetReader = XmlCharsetReader\n\t}\n\treturn xmlToMapParser(\"\", nil, p, r)\n}\n\n// xmlToMap - convert a XML doc into map[string]interface{} value\nfunc xmlToMap(doc []byte, r bool) (map[string]interface{}, error) {\n\tb := bytes.NewReader(doc)\n\tp := xml.NewDecoder(b)\n\tif CustomDecoder != nil {\n\t\tuseCustomDecoder(p)\n\t} else {\n\t\tp.CharsetReader = XmlCharsetReader\n\t}\n\treturn xmlToMapParser(\"\", nil, p, r)\n}\n\n// ===================================== where the work happens =============================\n\n// PrependAttrWithHyphen. Prepend attribute tags with a hyphen.\n// Default is 'true'. (Not applicable to NewMapXmlSeq(), mv.XmlSeq(), etc.)\n//\tNote:\n//\t\tIf 'false', unmarshaling and marshaling is not symmetric. Attributes will be\n//\t\tmarshal'd as attr and may be part of a list.\nfunc PrependAttrWithHyphen(v bool) {\n\tif v {\n\t\tattrPrefix = \"-\"\n\t\tlenAttrPrefix = len(attrPrefix)\n\t\treturn\n\t}\n\tattrPrefix = \"\"\n\tlenAttrPrefix = len(attrPrefix)\n}\n\n// Include sequence id with inner tags. - per Sean Murphy, murphysean84@gmail.com.\nvar includeTagSeqNum bool\n\n// IncludeTagSeqNum - include a \"_seq\":N key:value pair with each inner tag, denoting\n// its position when parsed. This is of limited usefulness, since list values cannot\n// be tagged with \"_seq\" without changing their depth in the Map.\n// So THIS SHOULD BE USED WITH CAUTION - see the test cases. Here's a sample of what\n// you get.\n/*\n\t\t\n\t\t\t\n\t\t\t\n\t\t\t\n\t\t\thello\n\t\t\n\n\tparses as:\n\n\t\t{\n\t\tObj:{\n\t\t\t\"-c\":\"la\",\n\t\t\t\"-h\":\"da\",\n\t\t\t\"-x\":\"dee\",\n\t\t\t\"intObj\":[\n\t\t\t\t{\n\t\t\t\t\t\"-id\"=\"3\",\n\t\t\t\t\t\"_seq\":\"0\" // if mxj.Cast is passed, then: \"_seq\":0\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\t\"-id\"=\"2\",\n\t\t\t\t\t\"_seq\":\"2\"\n\t\t\t\t}],\n\t\t\t\"intObj1\":{\n\t\t\t\t\"-id\":\"1\",\n\t\t\t\t\"_seq\":\"1\"\n\t\t\t\t},\n\t\t\t\"StrObj\":{\n\t\t\t\t\"#text\":\"hello\", // simple element value gets \"#text\" tag\n\t\t\t\t\"_seq\":\"3\"\n\t\t\t\t}\n\t\t\t}\n\t\t}\n*/\nfunc IncludeTagSeqNum(b ...bool) {\n\tif len(b) == 0 {\n\t\tincludeTagSeqNum = !includeTagSeqNum\n\t} else if len(b) == 1 {\n\t\tincludeTagSeqNum = b[0]\n\t}\n}\n\n// all keys will be \"lower case\"\nvar lowerCase bool\n\n// Coerce all tag values to keys in lower case. This is useful if you've got sources with variable\n// tag capitalization, and you want to use m.ValuesForKeys(), etc., with the key or path spec\n// in lower case.\n//\tCoerceKeysToLower() will toggle the coercion flag true|false - on|off\n//\tCoerceKeysToLower(true|false) will set the coercion flag on|off\n//\n//\tNOTE: only recognized by NewMapXml, NewMapXmlReader, and NewMapXmlReaderRaw functions as well as\n//\t the associated HandleXmlReader and HandleXmlReaderRaw.\nfunc CoerceKeysToLower(b ...bool) {\n\tif len(b) == 0 {\n\t\tlowerCase = !lowerCase\n\t} else if len(b) == 1 {\n\t\tlowerCase = b[0]\n\t}\n}\n\n// disableTrimWhiteSpace sets if the white space should be removed or not\nvar disableTrimWhiteSpace bool\nvar trimRunes = \"\\t\\r\\b\\n \"\n\n// DisableTrimWhiteSpace set if the white space should be trimmed or not. By default white space is always trimmed. If\n// no argument is provided, trim white space will be disabled.\nfunc DisableTrimWhiteSpace(b ...bool) {\n\tif len(b) == 0 {\n\t\tdisableTrimWhiteSpace = true\n\t} else {\n\t\tdisableTrimWhiteSpace = b[0]\n\t}\n\n\tif disableTrimWhiteSpace {\n\t\ttrimRunes = \"\\t\\r\\b\\n\"\n\t} else {\n\t\ttrimRunes = \"\\t\\r\\b\\n \"\n\t}\n}\n\n// 25jun16: Allow user to specify the \"prefix\" character for XML attribute key labels.\n// We do this by replacing '`' constant with attrPrefix var, replacing useHyphen with attrPrefix = \"\",\n// and adding a SetAttrPrefix(s string) function.\n\nvar attrPrefix string = `-` // the default\nvar lenAttrPrefix int = 1 // the default\n\n// SetAttrPrefix changes the default, \"-\", to the specified value, s.\n// SetAttrPrefix(\"\") is the same as PrependAttrWithHyphen(false).\n// (Not applicable for NewMapXmlSeq(), mv.XmlSeq(), etc.)\nfunc SetAttrPrefix(s string) {\n\tattrPrefix = s\n\tlenAttrPrefix = len(attrPrefix)\n}\n\n// 18jan17: Allows user to specify if the map keys should be in snake case instead\n// of the default hyphenated notation.\nvar snakeCaseKeys bool\n\n// CoerceKeysToSnakeCase changes the default, false, to the specified value, b.\n// Note: the attribute prefix will be a hyphen, '-', or what ever string value has\n// been specified using SetAttrPrefix.\nfunc CoerceKeysToSnakeCase(b ...bool) {\n\tif len(b) == 0 {\n\t\tsnakeCaseKeys = !snakeCaseKeys\n\t} else if len(b) == 1 {\n\t\tsnakeCaseKeys = b[0]\n\t}\n}\n\n// 10jan19: use of pull request #57 should be conditional - legacy code assumes\n// numeric values are float64.\nvar castToInt bool\n\n// CastValuesToInt tries to coerce numeric valus to int64 or uint64 instead of the\n// default float64. Repeated calls with no argument will toggle this on/off, or this\n// handling will be set with the value of 'b'.\nfunc CastValuesToInt(b ...bool) {\n\tif len(b) == 0 {\n\t\tcastToInt = !castToInt\n\t} else if len(b) == 1 {\n\t\tcastToInt = b[0]\n\t}\n}\n\n// 05feb17: support processing XMPP streams (issue #36)\nvar handleXMPPStreamTag bool\n\n// HandleXMPPStreamTag causes decoder to parse XMPP elements.\n// If called with no argument, XMPP stream element handling is toggled on/off.\n// (See xmppStream_test.go for example.)\n//\tIf called with NewMapXml, NewMapXmlReader, New MapXmlReaderRaw the \"stream\"\n//\telement will be returned as:\n//\t\tmap[\"stream\"]interface{}{map[-]interface{}}.\n//\tIf called with NewMapSeq, NewMapSeqReader, NewMapSeqReaderRaw the \"stream\"\n//\telement will be returned as:\n//\t\tmap[\"stream:stream\"]interface{}{map[\"#attr\"]interface{}{map[string]interface{}}}\n//\t\twhere the \"#attr\" values have \"#text\" and \"#seq\" keys. (See NewMapXmlSeq.)\nfunc HandleXMPPStreamTag(b ...bool) {\n\tif len(b) == 0 {\n\t\thandleXMPPStreamTag = !handleXMPPStreamTag\n\t} else if len(b) == 1 {\n\t\thandleXMPPStreamTag = b[0]\n\t}\n}\n\n// 21jan18 - decode all values as map[\"#text\":value] (issue #56)\nvar decodeSimpleValuesAsMap bool\n\n// DecodeSimpleValuesAsMap forces all values to be decoded as map[\"#text\":].\n// If called with no argument, the decoding is toggled on/off.\n//\n// By default the NewMapXml functions decode simple values without attributes as\n// map[:]. This function causes simple values without attributes to be\n// decoded the same as simple values with attributes - map[:map[\"#text\":]].\nfunc DecodeSimpleValuesAsMap(b ...bool) {\n\tif len(b) == 0 {\n\t\tdecodeSimpleValuesAsMap = !decodeSimpleValuesAsMap\n\t} else if len(b) == 1 {\n\t\tdecodeSimpleValuesAsMap = b[0]\n\t}\n}\n\n// xmlToMapParser (2015.11.12) - load a 'clean' XML doc into a map[string]interface{} directly.\n// A refactoring of xmlToTreeParser(), markDuplicate() and treeToMap() - here, all-in-one.\n// We've removed the intermediate *node tree with the allocation and subsequent rescanning.\nfunc xmlToMapParser(skey string, a []xml.Attr, p *xml.Decoder, r bool) (map[string]interface{}, error) {\n\tif lowerCase {\n\t\tskey = strings.ToLower(skey)\n\t}\n\tif snakeCaseKeys {\n\t\tskey = strings.Replace(skey, \"-\", \"_\", -1)\n\t}\n\n\t// NOTE: all attributes and sub-elements parsed into 'na', 'na' is returned as value for 'skey' in 'n'.\n\t// Unless 'skey' is a simple element w/o attributes, in which case the xml.CharData value is the value.\n\tvar n, na map[string]interface{}\n\tvar seq int // for includeTagSeqNum\n\n\t// Allocate maps and load attributes, if any.\n\t// NOTE: on entry from NewMapXml(), etc., skey==\"\", and we fall through\n\t// to get StartElement then recurse with skey==xml.StartElement.Name.Local\n\t// where we begin allocating map[string]interface{} values 'n' and 'na'.\n\tif skey != \"\" {\n\t\tn = make(map[string]interface{}) // old n\n\t\tna = make(map[string]interface{}) // old n.nodes\n\t\tif len(a) > 0 {\n\t\t\tfor _, v := range a {\n\t\t\t\tif snakeCaseKeys {\n\t\t\t\t\tv.Name.Local = strings.Replace(v.Name.Local, \"-\", \"_\", -1)\n\t\t\t\t}\n\t\t\t\tvar key string\n\t\t\t\tkey = attrPrefix + v.Name.Local\n\t\t\t\tif lowerCase {\n\t\t\t\t\tkey = strings.ToLower(key)\n\t\t\t\t}\n\t\t\t\tif xmlEscapeCharsDecoder { // per issue#84\n\t\t\t\t\tv.Value = escapeChars(v.Value)\n\t\t\t\t}\n\t\t\t\tna[key] = cast(v.Value, r, key)\n\t\t\t}\n\t\t}\n\t}\n\t// Return XMPP message.\n\tif handleXMPPStreamTag && skey == \"stream\" {\n\t\tn[skey] = na\n\t\treturn n, nil\n\t}\n\n\tfor {\n\t\tt, err := p.Token()\n\t\tif err != nil {\n\t\t\tif err != io.EOF {\n\t\t\t\treturn nil, errors.New(\"xml.Decoder.Token() - \" + err.Error())\n\t\t\t}\n\t\t\treturn nil, err\n\t\t}\n\t\tswitch t.(type) {\n\t\tcase xml.StartElement:\n\t\t\ttt := t.(xml.StartElement)\n\n\t\t\t// First call to xmlToMapParser() doesn't pass xml.StartElement - the map key.\n\t\t\t// So when the loop is first entered, the first token is the root tag along\n\t\t\t// with any attributes, which we process here.\n\t\t\t//\n\t\t\t// Subsequent calls to xmlToMapParser() will pass in tag+attributes for\n\t\t\t// processing before getting the next token which is the element value,\n\t\t\t// which is done above.\n\t\t\tif skey == \"\" {\n\t\t\t\treturn xmlToMapParser(tt.Name.Local, tt.Attr, p, r)\n\t\t\t}\n\n\t\t\t// If not initializing the map, parse the element.\n\t\t\t// len(nn) == 1, necessarily - it is just an 'n'.\n\t\t\tnn, err := xmlToMapParser(tt.Name.Local, tt.Attr, p, r)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\t// The nn map[string]interface{} value is a na[nn_key] value.\n\t\t\t// We need to see if nn_key already exists - means we're parsing a list.\n\t\t\t// This may require converting na[nn_key] value into []interface{} type.\n\t\t\t// First, extract the key:val for the map - it's a singleton.\n\t\t\t// Note:\n\t\t\t// * if CoerceKeysToLower() called, then key will be lower case.\n\t\t\t// * if CoerceKeysToSnakeCase() called, then key will be converted to snake case.\n\t\t\tvar key string\n\t\t\tvar val interface{}\n\t\t\tfor key, val = range nn {\n\t\t\t\tbreak\n\t\t\t}\n\n\t\t\t// IncludeTagSeqNum requests that the element be augmented with a \"_seq\" sub-element.\n\t\t\t// In theory, we don't need this if len(na) == 1. But, we don't know what might\n\t\t\t// come next - we're only parsing forward. So if you ask for 'includeTagSeqNum' you\n\t\t\t// get it on every element. (Personally, I never liked this, but I added it on request\n\t\t\t// and did get a $50 Amazon gift card in return - now we support it for backwards compatibility!)\n\t\t\tif includeTagSeqNum {\n\t\t\t\tswitch val.(type) {\n\t\t\t\tcase []interface{}:\n\t\t\t\t\t// noop - There's no clean way to handle this w/o changing message structure.\n\t\t\t\tcase map[string]interface{}:\n\t\t\t\t\tval.(map[string]interface{})[\"_seq\"] = seq // will overwrite an \"_seq\" XML tag\n\t\t\t\t\tseq++\n\t\t\t\tcase interface{}: // a non-nil simple element: string, float64, bool\n\t\t\t\t\tv := map[string]interface{}{textK: val}\n\t\t\t\t\tv[\"_seq\"] = seq\n\t\t\t\t\tseq++\n\t\t\t\t\tval = v\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// 'na' holding sub-elements of n.\n\t\t\t// See if 'key' already exists.\n\t\t\t// If 'key' exists, then this is a list, if not just add key:val to na.\n\t\t\tif v, ok := na[key]; ok {\n\t\t\t\tvar a []interface{}\n\t\t\t\tswitch v.(type) {\n\t\t\t\tcase []interface{}:\n\t\t\t\t\ta = v.([]interface{})\n\t\t\t\tdefault: // anything else - note: v.(type) != nil\n\t\t\t\t\ta = []interface{}{v}\n\t\t\t\t}\n\t\t\t\ta = append(a, val)\n\t\t\t\tna[key] = a\n\t\t\t} else {\n\t\t\t\tna[key] = val // save it as a singleton\n\t\t\t}\n\t\tcase xml.EndElement:\n\t\t\t// len(n) > 0 if this is a simple element w/o xml.Attrs - see xml.CharData case.\n\t\t\tif len(n) == 0 {\n\t\t\t\t// If len(na)==0 we have an empty element == \"\";\n\t\t\t\t// it has no xml.Attr nor xml.CharData.\n\t\t\t\t// Note: in original node-tree parser, val defaulted to \"\";\n\t\t\t\t// so we always had the default if len(node.nodes) == 0.\n\t\t\t\tif len(na) > 0 {\n\t\t\t\t\tn[skey] = na\n\t\t\t\t} else {\n\t\t\t\t\tn[skey] = \"\" // empty element\n\t\t\t\t}\n\t\t\t} else if len(n) == 1 && len(na) > 0 {\n\t\t\t\t// it's a simple element w/ no attributes w/ subelements\n\t\t\t\tfor _, v := range n {\n\t\t\t\t\tna[textK] = v\n\t\t\t\t}\n\t\t\t\tn[skey] = na\n\t\t\t}\n\t\t\treturn n, nil\n\t\tcase xml.CharData:\n\t\t\t// clean up possible noise\n\t\t\ttt := strings.Trim(string(t.(xml.CharData)), trimRunes)\n\t\t\tif xmlEscapeCharsDecoder { // issue#84\n\t\t\t\ttt = escapeChars(tt)\n\t\t\t}\n\t\t\tif len(tt) > 0 {\n\t\t\t\tif len(na) > 0 || decodeSimpleValuesAsMap {\n\t\t\t\t\tna[textK] = cast(tt, r, textK)\n\t\t\t\t} else if skey != \"\" {\n\t\t\t\t\tn[skey] = cast(tt, r, skey)\n\t\t\t\t} else {\n\t\t\t\t\t// per Adrian (http://www.adrianlungu.com/) catch stray text\n\t\t\t\t\t// in decoder stream -\n\t\t\t\t\t// https://github.com/clbanning/mxj/pull/14#issuecomment-182816374\n\t\t\t\t\t// NOTE: CharSetReader must be set to non-UTF-8 CharSet or you'll get\n\t\t\t\t\t// a p.Token() decoding error when the BOM is UTF-16 or UTF-32.\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t}\n\t\tdefault:\n\t\t\t// noop\n\t\t}\n\t}\n}\n\nvar castNanInf bool\n\n// Cast \"Nan\", \"Inf\", \"-Inf\" XML values to 'float64'.\n// By default, these values will be decoded as 'string'.\nfunc CastNanInf(b ...bool) {\n\tif len(b) == 0 {\n\t\tcastNanInf = !castNanInf\n\t} else if len(b) == 1 {\n\t\tcastNanInf = b[0]\n\t}\n}\n\n// cast - try to cast string values to bool or float64\n// 't' is the tag key that can be checked for 'not-casting'\nfunc cast(s string, r bool, t string) interface{} {\n\tif checkTagToSkip != nil && t != \"\" && checkTagToSkip(t) {\n\t\t// call the check-function here with 't[0]'\n\t\t// if 'true' return s\n\t\treturn s\n\t}\n\n\tif r {\n\t\t// handle nan and inf\n\t\tif !castNanInf {\n\t\t\tswitch strings.ToLower(s) {\n\t\t\tcase \"nan\", \"inf\", \"-inf\":\n\t\t\t\treturn s\n\t\t\t}\n\t\t}\n\n\t\t// handle numeric strings ahead of boolean\n\t\tif castToInt {\n\t\t\tif f, err := strconv.ParseInt(s, 10, 64); err == nil {\n\t\t\t\treturn f\n\t\t\t}\n\t\t\tif f, err := strconv.ParseUint(s, 10, 64); err == nil {\n\t\t\t\treturn f\n\t\t\t}\n\t\t}\n\n\t\tif castToFloat {\n\t\t\tif f, err := strconv.ParseFloat(s, 64); err == nil {\n\t\t\t\treturn f\n\t\t\t}\n\t\t}\n\n\t\t// ParseBool treats \"1\"==true & \"0\"==false, we've already scanned those\n\t\t// values as float64. See if value has 't' or 'f' as initial screen to\n\t\t// minimize calls to ParseBool; also, see if len(s) < 6.\n\t\tif castToBool {\n\t\t\tif len(s) > 0 && len(s) < 6 {\n\t\t\t\tswitch s[:1] {\n\t\t\t\tcase \"t\", \"T\", \"f\", \"F\":\n\t\t\t\t\tif b, err := strconv.ParseBool(s); err == nil {\n\t\t\t\t\t\treturn b\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn s\n}\n\n// pull request, #59\nvar castToFloat = true\n\n// CastValuesToFloat can be used to skip casting to float64 when\n// \"cast\" argument is 'true' in NewMapXml, etc.\n// Default is true.\nfunc CastValuesToFloat(b ...bool) {\n\tif len(b) == 0 {\n\t\tcastToFloat = !castToFloat\n\t} else if len(b) == 1 {\n\t\tcastToFloat = b[0]\n\t}\n}\n\nvar castToBool = true\n\n// CastValuesToBool can be used to skip casting to bool when\n// \"cast\" argument is 'true' in NewMapXml, etc.\n// Default is true.\nfunc CastValuesToBool(b ...bool) {\n\tif len(b) == 0 {\n\t\tcastToBool = !castToBool\n\t} else if len(b) == 1 {\n\t\tcastToBool = b[0]\n\t}\n}\n\n// checkTagToSkip - switch to address Issue #58\n\nvar checkTagToSkip func(string) bool\n\n// SetCheckTagToSkipFunc registers function to test whether the value\n// for a tag should be cast to bool or float64 when \"cast\" argument is 'true'.\n// (Dot tag path notation is not supported.)\n// NOTE: key may be \"#text\" if it's a simple element with attributes\n// or \"decodeSimpleValuesAsMap == true\".\n// NOTE: does not apply to NewMapXmlSeq... functions.\nfunc SetCheckTagToSkipFunc(fn func(string) bool) {\n\tcheckTagToSkip = fn\n}\n\n// ------------------ END: NewMapXml & NewMapXmlReader -------------------------\n\n// ------------------ mv.Xml & mv.XmlWriter - from j2x ------------------------\n\nconst (\n\tDefaultRootTag = \"doc\"\n)\n\nvar useGoXmlEmptyElemSyntax bool\n\n// XmlGoEmptyElemSyntax() - rather than .\n//\tGo's encoding/xml package marshals empty XML elements as . By default this package\n//\tencodes empty elements as . If you're marshaling Map values that include structures\n//\t(which are passed to xml.Marshal for encoding), this will let you conform to the standard package.\nfunc XmlGoEmptyElemSyntax() {\n\tuseGoXmlEmptyElemSyntax = true\n}\n\n// XmlDefaultEmptyElemSyntax() - rather than .\n// Return XML encoding for empty elements to the default package setting.\n// Reverses effect of XmlGoEmptyElemSyntax().\nfunc XmlDefaultEmptyElemSyntax() {\n\tuseGoXmlEmptyElemSyntax = false\n}\n\n// ------- issue #88 ----------\n// xmlCheckIsValid set switch to force decoding the encoded XML to\n// see if it is valid XML.\nvar xmlCheckIsValid bool\n\n// XmlCheckIsValid forces the encoded XML to be checked for validity.\nfunc XmlCheckIsValid(b ...bool) {\n\tif len(b) == 1 {\n\t\txmlCheckIsValid = b[0]\n\t\treturn\n\t}\n\txmlCheckIsValid = !xmlCheckIsValid\n}\n\n// Encode a Map as XML. The companion of NewMapXml().\n// The following rules apply.\n// - The key label \"#text\" is treated as the value for a simple element with attributes.\n// - Map keys that begin with a hyphen, '-', are interpreted as attributes.\n// It is an error if the attribute doesn't have a []byte, string, number, or boolean value.\n// - Map value type encoding:\n// > string, bool, float64, int, int32, int64, float32: per \"%v\" formating\n// > []bool, []uint8: by casting to string\n// > structures, etc.: handed to xml.Marshal() - if there is an error, the element\n// value is \"UNKNOWN\"\n// - Elements with only attribute values or are null are terminated using \"/>\".\n// - If len(mv) == 1 and no rootTag is provided, then the map key is used as the root tag, possible.\n// Thus, `{ \"key\":\"value\" }` encodes as \"value\".\n// - To encode empty elements in a syntax consistent with encoding/xml call UseGoXmlEmptyElementSyntax().\n// The attributes tag=value pairs are alphabetized by \"tag\". Also, when encoding map[string]interface{} values -\n// complex elements, etc. - the key:value pairs are alphabetized by key so the resulting tags will appear sorted.\nfunc (mv Map) Xml(rootTag ...string) ([]byte, error) {\n\tm := map[string]interface{}(mv)\n\tvar err error\n\tb := new(bytes.Buffer)\n\tp := new(pretty) // just a stub\n\n\tif len(m) == 1 && len(rootTag) == 0 {\n\t\tfor key, value := range m {\n\t\t\t// if it an array, see if all values are map[string]interface{}\n\t\t\t// we force a new root tag if we'll end up with no key:value in the list\n\t\t\t// so: key:[string_val, bool:true] --> string_valtrue\n\t\t\tswitch value.(type) {\n\t\t\tcase []interface{}:\n\t\t\t\tfor _, v := range value.([]interface{}) {\n\t\t\t\t\tswitch v.(type) {\n\t\t\t\t\tcase map[string]interface{}: // noop\n\t\t\t\t\tdefault: // anything else\n\t\t\t\t\t\terr = marshalMapToXmlIndent(false, b, DefaultRootTag, m, p)\n\t\t\t\t\t\tgoto done\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\terr = marshalMapToXmlIndent(false, b, key, value, p)\n\t\t}\n\t} else if len(rootTag) == 1 {\n\t\terr = marshalMapToXmlIndent(false, b, rootTag[0], m, p)\n\t} else {\n\t\terr = marshalMapToXmlIndent(false, b, DefaultRootTag, m, p)\n\t}\ndone:\n\tif xmlCheckIsValid {\n\t\td := xml.NewDecoder(bytes.NewReader(b.Bytes()))\n\t\tfor {\n\t\t\t_, err = d.Token()\n\t\t\tif err == io.EOF {\n\t\t\t\terr = nil\n\t\t\t\tbreak\n\t\t\t} else if err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t}\n\t}\n\treturn b.Bytes(), err\n}\n\n// The following implementation is provided only for symmetry with NewMapXmlReader[Raw]\n// The names will also provide a key for the number of return arguments.\n\n// Writes the Map as XML on the Writer.\n// See Xml() for encoding rules.\nfunc (mv Map) XmlWriter(xmlWriter io.Writer, rootTag ...string) error {\n\tx, err := mv.Xml(rootTag...)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t_, err = xmlWriter.Write(x)\n\treturn err\n}\n\n// Writes the Map as XML on the Writer. []byte is the raw XML that was written.\n// See Xml() for encoding rules.\n/*\nfunc (mv Map) XmlWriterRaw(xmlWriter io.Writer, rootTag ...string) ([]byte, error) {\n\tx, err := mv.Xml(rootTag...)\n\tif err != nil {\n\t\treturn x, err\n\t}\n\n\t_, err = xmlWriter.Write(x)\n\treturn x, err\n}\n*/\n\n// Writes the Map as pretty XML on the Writer.\n// See Xml() for encoding rules.\nfunc (mv Map) XmlIndentWriter(xmlWriter io.Writer, prefix, indent string, rootTag ...string) error {\n\tx, err := mv.XmlIndent(prefix, indent, rootTag...)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t_, err = xmlWriter.Write(x)\n\treturn err\n}\n\n// Writes the Map as pretty XML on the Writer. []byte is the raw XML that was written.\n// See Xml() for encoding rules.\n/*\nfunc (mv Map) XmlIndentWriterRaw(xmlWriter io.Writer, prefix, indent string, rootTag ...string) ([]byte, error) {\n\tx, err := mv.XmlIndent(prefix, indent, rootTag...)\n\tif err != nil {\n\t\treturn x, err\n\t}\n\n\t_, err = xmlWriter.Write(x)\n\treturn x, err\n}\n*/\n\n// -------------------- END: mv.Xml & mv.XmlWriter -------------------------------\n\n// -------------- Handle XML stream by processing Map value --------------------\n\n// Default poll delay to keep Handler from spinning on an open stream\n// like sitting on os.Stdin waiting for imput.\nvar xhandlerPollInterval = time.Millisecond\n\n// Bulk process XML using handlers that process a Map value.\n//\t'rdr' is an io.Reader for XML (stream)\n//\t'mapHandler' is the Map processor. Return of 'false' stops io.Reader processing.\n//\t'errHandler' is the error processor. Return of 'false' stops io.Reader processing and returns the error.\n//\tNote: mapHandler() and errHandler() calls are blocking, so reading and processing of messages is serialized.\n//\t This means that you can stop reading the file on error or after processing a particular message.\n//\t To have reading and handling run concurrently, pass argument to a go routine in handler and return 'true'.\nfunc HandleXmlReader(xmlReader io.Reader, mapHandler func(Map) bool, errHandler func(error) bool) error {\n\tvar n int\n\tfor {\n\t\tm, merr := NewMapXmlReader(xmlReader)\n\t\tn++\n\n\t\t// handle error condition with errhandler\n\t\tif merr != nil && merr != io.EOF {\n\t\t\tmerr = fmt.Errorf(\"[xmlReader: %d] %s\", n, merr.Error())\n\t\t\tif ok := errHandler(merr); !ok {\n\t\t\t\t// caused reader termination\n\t\t\t\treturn merr\n\t\t\t}\n\t\t\tcontinue\n\t\t}\n\n\t\t// pass to maphandler\n\t\tif len(m) != 0 {\n\t\t\tif ok := mapHandler(m); !ok {\n\t\t\t\tbreak\n\t\t\t}\n\t\t} else if merr != io.EOF {\n\t\t\ttime.Sleep(xhandlerPollInterval)\n\t\t}\n\n\t\tif merr == io.EOF {\n\t\t\tbreak\n\t\t}\n\t}\n\treturn nil\n}\n\n// Bulk process XML using handlers that process a Map value and the raw XML.\n//\t'rdr' is an io.Reader for XML (stream)\n//\t'mapHandler' is the Map and raw XML - []byte - processor. Return of 'false' stops io.Reader processing.\n//\t'errHandler' is the error and raw XML processor. Return of 'false' stops io.Reader processing and returns the error.\n//\tNote: mapHandler() and errHandler() calls are blocking, so reading and processing of messages is serialized.\n//\t This means that you can stop reading the file on error or after processing a particular message.\n//\t To have reading and handling run concurrently, pass argument(s) to a go routine in handler and return 'true'.\n//\tSee NewMapXmlReaderRaw for comment on performance associated with retrieving raw XML from a Reader.\nfunc HandleXmlReaderRaw(xmlReader io.Reader, mapHandler func(Map, []byte) bool, errHandler func(error, []byte) bool) error {\n\tvar n int\n\tfor {\n\t\tm, raw, merr := NewMapXmlReaderRaw(xmlReader)\n\t\tn++\n\n\t\t// handle error condition with errhandler\n\t\tif merr != nil && merr != io.EOF {\n\t\t\tmerr = fmt.Errorf(\"[xmlReader: %d] %s\", n, merr.Error())\n\t\t\tif ok := errHandler(merr, raw); !ok {\n\t\t\t\t// caused reader termination\n\t\t\t\treturn merr\n\t\t\t}\n\t\t\tcontinue\n\t\t}\n\n\t\t// pass to maphandler\n\t\tif len(m) != 0 {\n\t\t\tif ok := mapHandler(m, raw); !ok {\n\t\t\t\tbreak\n\t\t\t}\n\t\t} else if merr != io.EOF {\n\t\t\ttime.Sleep(xhandlerPollInterval)\n\t\t}\n\n\t\tif merr == io.EOF {\n\t\t\tbreak\n\t\t}\n\t}\n\treturn nil\n}\n\n// ----------------- END: Handle XML stream by processing Map value --------------\n\n// -------- a hack of io.TeeReader ... need one that's an io.ByteReader for xml.NewDecoder() ----------\n\n// This is a clone of io.TeeReader with the additional method t.ReadByte().\n// Thus, this TeeReader is also an io.ByteReader.\n// This is necessary because xml.NewDecoder uses a ByteReader not a Reader. It appears to have been written\n// with bufio.Reader or bytes.Reader in mind ... not a generic io.Reader, which doesn't have to have ReadByte()..\n// If NewDecoder is passed a Reader that does not satisfy ByteReader() it wraps the Reader with\n// bufio.NewReader and uses ReadByte rather than Read that runs the TeeReader pipe logic.\n\ntype teeReader struct {\n\tr io.Reader\n\tw io.Writer\n\tb []byte\n}\n\nfunc myTeeReader(r io.Reader, w io.Writer) io.Reader {\n\tb := make([]byte, 1)\n\treturn &teeReader{r, w, b}\n}\n\n// need for io.Reader - but we don't use it ...\nfunc (t *teeReader) Read(p []byte) (int, error) {\n\treturn 0, nil\n}\n\nfunc (t *teeReader) ReadByte() (byte, error) {\n\tn, err := t.r.Read(t.b)\n\tif n > 0 {\n\t\tif _, err := t.w.Write(t.b[:1]); err != nil {\n\t\t\treturn t.b[0], err\n\t\t}\n\t}\n\treturn t.b[0], err\n}\n\n// For use with NewMapXmlReader & NewMapXmlSeqReader.\ntype byteReader struct {\n\tr io.Reader\n\tb []byte\n}\n\nfunc myByteReader(r io.Reader) io.Reader {\n\tb := make([]byte, 1)\n\treturn &byteReader{r, b}\n}\n\n// Need for io.Reader interface ...\n// Needed if reading a malformed http.Request.Body - issue #38.\nfunc (b *byteReader) Read(p []byte) (int, error) {\n\treturn b.r.Read(p)\n}\n\nfunc (b *byteReader) ReadByte() (byte, error) {\n\t_, err := b.r.Read(b.b)\n\tif len(b.b) > 0 {\n\t\t// issue #38\n\t\treturn b.b[0], err\n\t}\n\tvar c byte\n\treturn c, err\n}\n\n// ----------------------- END: io.TeeReader hack -----------------------------------\n\n// ---------------------- XmlIndent - from j2x package ----------------------------\n\n// Encode a map[string]interface{} as a pretty XML string.\n// See Xml for encoding rules.\nfunc (mv Map) XmlIndent(prefix, indent string, rootTag ...string) ([]byte, error) {\n\tm := map[string]interface{}(mv)\n\n\tvar err error\n\tb := new(bytes.Buffer)\n\tp := new(pretty)\n\tp.indent = indent\n\tp.padding = prefix\n\n\tif len(m) == 1 && len(rootTag) == 0 {\n\t\t// this can extract the key for the single map element\n\t\t// use it if it isn't a key for a list\n\t\tfor key, value := range m {\n\t\t\tif _, ok := value.([]interface{}); ok {\n\t\t\t\terr = marshalMapToXmlIndent(true, b, DefaultRootTag, m, p)\n\t\t\t} else {\n\t\t\t\terr = marshalMapToXmlIndent(true, b, key, value, p)\n\t\t\t}\n\t\t}\n\t} else if len(rootTag) == 1 {\n\t\terr = marshalMapToXmlIndent(true, b, rootTag[0], m, p)\n\t} else {\n\t\terr = marshalMapToXmlIndent(true, b, DefaultRootTag, m, p)\n\t}\n\tif xmlCheckIsValid {\n\t\td := xml.NewDecoder(bytes.NewReader(b.Bytes()))\n\t\tfor {\n\t\t\t_, err = d.Token()\n\t\t\tif err == io.EOF {\n\t\t\t\terr = nil\n\t\t\t\tbreak\n\t\t\t} else if err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t}\n\t}\n\treturn b.Bytes(), err\n}\n\ntype pretty struct {\n\tindent string\n\tcnt int\n\tpadding string\n\tmapDepth int\n\tstart int\n}\n\nfunc (p *pretty) Indent() {\n\tp.padding += p.indent\n\tp.cnt++\n}\n\nfunc (p *pretty) Outdent() {\n\tif p.cnt > 0 {\n\t\tp.padding = p.padding[:len(p.padding)-len(p.indent)]\n\t\tp.cnt--\n\t}\n}\n\n// where the work actually happens\n// returns an error if an attribute is not atomic\n// NOTE: 01may20 - replaces mapToXmlIndent(); uses bytes.Buffer instead for string appends.\nfunc marshalMapToXmlIndent(doIndent bool, b *bytes.Buffer, key string, value interface{}, pp *pretty) error {\n\tvar err error\n\tvar endTag bool\n\tvar isSimple bool\n\tvar elen int\n\tp := &pretty{pp.indent, pp.cnt, pp.padding, pp.mapDepth, pp.start}\n\n\t// per issue #48, 18apr18 - try and coerce maps to map[string]interface{}\n\t// Don't need for mapToXmlSeqIndent, since maps there are decoded by NewMapXmlSeq().\n\tif reflect.ValueOf(value).Kind() == reflect.Map {\n\t\tswitch value.(type) {\n\t\tcase map[string]interface{}:\n\t\tdefault:\n\t\t\tval := make(map[string]interface{})\n\t\t\tvv := reflect.ValueOf(value)\n\t\t\tkeys := vv.MapKeys()\n\t\t\tfor _, k := range keys {\n\t\t\t\tval[fmt.Sprint(k)] = vv.MapIndex(k).Interface()\n\t\t\t}\n\t\t\tvalue = val\n\t\t}\n\t}\n\n\t// 14jul20. The following block of code has become something of a catch all for odd stuff\n\t// that might be passed in as a result of casting an arbitrary map[] to an mxj.Map\n\t// value and then call m.Xml or m.XmlIndent. See issue #71 (and #73) for such edge cases.\n\tswitch value.(type) {\n\t// these types are handled during encoding\n\tcase map[string]interface{}, []byte, string, float64, bool, int, int32, int64, float32, json.Number:\n\tcase []map[string]interface{}, []string, []float64, []bool, []int, []int32, []int64, []float32, []json.Number:\n\tcase []interface{}:\n\tcase nil:\n\t\tvalue = \"\"\n\tdefault:\n\t\t// see if value is a struct, if so marshal using encoding/xml package\n\t\tif reflect.ValueOf(value).Kind() == reflect.Struct {\n\t\t\tif v, err := xml.Marshal(value); err != nil {\n\t\t\t\treturn err\n\t\t\t} else {\n\t\t\t\tvalue = string(v)\n\t\t\t}\n\t\t} else {\n\t\t\t// coerce eveything else into a string value\n\t\t\tvalue = fmt.Sprint(value)\n\t\t}\n\t}\n\n\t// start the XML tag with required indentaton and padding\n\tif doIndent {\n\t\tswitch value.(type) {\n\t\tcase []interface{}, []string:\n\t\t\t// list processing handles indentation for all elements\n\t\tdefault:\n\t\t\tif _, err = b.WriteString(p.padding); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t}\n\tswitch value.(type) {\n\tcase []interface{}:\n\tdefault:\n\t\tif _, err = b.WriteString(`<` + key); err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\n\tswitch value.(type) {\n\tcase map[string]interface{}:\n\t\tvv := value.(map[string]interface{})\n\t\tlenvv := len(vv)\n\t\t// scan out attributes - attribute keys have prepended attrPrefix\n\t\tattrlist := make([][2]string, len(vv))\n\t\tvar n int\n\t\tvar ss string\n\t\tfor k, v := range vv {\n\t\t\tif lenAttrPrefix > 0 && lenAttrPrefix < len(k) && k[:lenAttrPrefix] == attrPrefix {\n\t\t\t\tswitch v.(type) {\n\t\t\t\tcase string:\n\t\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\t\tss = escapeChars(v.(string))\n\t\t\t\t\t} else {\n\t\t\t\t\t\tss = v.(string)\n\t\t\t\t\t}\n\t\t\t\t\tattrlist[n][0] = k[lenAttrPrefix:]\n\t\t\t\t\tattrlist[n][1] = ss\n\t\t\t\tcase float64, bool, int, int32, int64, float32, json.Number:\n\t\t\t\t\tattrlist[n][0] = k[lenAttrPrefix:]\n\t\t\t\t\tattrlist[n][1] = fmt.Sprintf(\"%v\", v)\n\t\t\t\tcase []byte:\n\t\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\t\tss = escapeChars(string(v.([]byte)))\n\t\t\t\t\t} else {\n\t\t\t\t\t\tss = string(v.([]byte))\n\t\t\t\t\t}\n\t\t\t\t\tattrlist[n][0] = k[lenAttrPrefix:]\n\t\t\t\t\tattrlist[n][1] = ss\n\t\t\t\tdefault:\n\t\t\t\t\treturn fmt.Errorf(\"invalid attribute value for: %s:<%T>\", k, v)\n\t\t\t\t}\n\t\t\t\tn++\n\t\t\t}\n\t\t}\n\t\tif n > 0 {\n\t\t\tattrlist = attrlist[:n]\n\t\t\tsort.Sort(attrList(attrlist))\n\t\t\tfor _, v := range attrlist {\n\t\t\t\tif _, err = b.WriteString(` ` + v[0] + `=\"` + v[1] + `\"`); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t// only attributes?\n\t\tif n == lenvv {\n\t\t\tif useGoXmlEmptyElemSyntax {\n\t\t\t\tif _, err = b.WriteString(`\"); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif _, err = b.WriteString(`/>`); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak\n\t\t}\n\n\t\t// simple element? Note: '#text\" is an invalid XML tag.\n\t\tisComplex := false\n\t\tif v, ok := vv[textK]; ok && n+1 == lenvv {\n\t\t\t// just the value and attributes\n\t\t\tswitch v.(type) {\n\t\t\tcase string:\n\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\tv = escapeChars(v.(string))\n\t\t\t\t} else {\n\t\t\t\t\tv = v.(string)\n\t\t\t\t}\n\t\t\tcase []byte:\n\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\tv = escapeChars(string(v.([]byte)))\n\t\t\t\t} else {\n\t\t\t\t\tv = string(v.([]byte))\n\t\t\t\t}\n\t\t\t}\n\t\t\tif _, err = b.WriteString(\">\" + fmt.Sprintf(\"%v\", v)); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tendTag = true\n\t\t\telen = 1\n\t\t\tisSimple = true\n\t\t\tbreak\n\t\t} else if ok {\n\t\t\t// need to handle when there are subelements in addition to the simple element value\n\t\t\t// issue #90\n\t\t\tswitch v.(type) {\n\t\t\tcase string:\n\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\tv = escapeChars(v.(string))\n\t\t\t\t} else {\n\t\t\t\t\tv = v.(string)\n\t\t\t\t}\n\t\t\tcase []byte:\n\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\tv = escapeChars(string(v.([]byte)))\n\t\t\t\t} else {\n\t\t\t\t\tv = string(v.([]byte))\n\t\t\t\t}\n\t\t\t}\n\t\t\tif _, err = b.WriteString(\">\" + fmt.Sprintf(\"%v\", v)); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tisComplex = true\n\t\t}\n\n\t\t// close tag with possible attributes\n\t\tif !isComplex {\n\t\t\tif _, err = b.WriteString(\">\"); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\tif doIndent {\n\t\t\t// *s += \"\\n\"\n\t\t\tif _, err = b.WriteString(\"\\n\"); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\t// something more complex\n\t\tp.mapDepth++\n\t\t// extract the map k:v pairs and sort on key\n\t\telemlist := make([][2]interface{}, len(vv))\n\t\tn = 0\n\t\tfor k, v := range vv {\n\t\t\tif k == textK {\n\t\t\t\t// simple element handled above\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif lenAttrPrefix > 0 && lenAttrPrefix < len(k) && k[:lenAttrPrefix] == attrPrefix {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\telemlist[n][0] = k\n\t\t\telemlist[n][1] = v\n\t\t\tn++\n\t\t}\n\t\telemlist = elemlist[:n]\n\t\tsort.Sort(elemList(elemlist))\n\t\tvar i int\n\t\tfor _, v := range elemlist {\n\t\t\tswitch v[1].(type) {\n\t\t\tcase []interface{}:\n\t\t\tdefault:\n\t\t\t\tif i == 0 && doIndent {\n\t\t\t\t\tp.Indent()\n\t\t\t\t}\n\t\t\t}\n\t\t\ti++\n\t\t\tif err := marshalMapToXmlIndent(doIndent, b, v[0].(string), v[1], p); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tswitch v[1].(type) {\n\t\t\tcase []interface{}: // handled in []interface{} case\n\t\t\tdefault:\n\t\t\t\tif doIndent {\n\t\t\t\t\tp.Outdent()\n\t\t\t\t}\n\t\t\t}\n\t\t\ti--\n\t\t}\n\t\tp.mapDepth--\n\t\tendTag = true\n\t\telen = 1 // we do have some content ...\n\tcase []interface{}:\n\t\t// special case - found during implementing Issue #23\n\t\tif len(value.([]interface{})) == 0 {\n\t\t\tif doIndent {\n\t\t\t\tif _, err = b.WriteString(p.padding + p.indent); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t\tif _, err = b.WriteString(\"<\" + key); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\telen = 0\n\t\t\tendTag = true\n\t\t\tbreak\n\t\t}\n\t\tfor _, v := range value.([]interface{}) {\n\t\t\tif doIndent {\n\t\t\t\tp.Indent()\n\t\t\t}\n\t\t\tif err := marshalMapToXmlIndent(doIndent, b, key, v, p); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tif doIndent {\n\t\t\t\tp.Outdent()\n\t\t\t}\n\t\t}\n\t\treturn nil\n\tcase []string:\n\t\t// This was added by https://github.com/slotix ... not a type that\n\t\t// would be encountered if mv generated from NewMapXml, NewMapJson.\n\t\t// Could be encountered in AnyXml(), so we'll let it stay, though\n\t\t// it should be merged with case []interface{}, above.\n\t\t//quick fix for []string type\n\t\t//[]string should be treated exaclty as []interface{}\n\t\tif len(value.([]string)) == 0 {\n\t\t\tif doIndent {\n\t\t\t\tif _, err = b.WriteString(p.padding + p.indent); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t\tif _, err = b.WriteString(\"<\" + key); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\telen = 0\n\t\t\tendTag = true\n\t\t\tbreak\n\t\t}\n\t\tfor _, v := range value.([]string) {\n\t\t\tif doIndent {\n\t\t\t\tp.Indent()\n\t\t\t}\n\t\t\tif err := marshalMapToXmlIndent(doIndent, b, key, v, p); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tif doIndent {\n\t\t\t\tp.Outdent()\n\t\t\t}\n\t\t}\n\t\treturn nil\n\tcase nil:\n\t\t// terminate the tag\n\t\tif doIndent {\n\t\t\t// *s += p.padding\n\t\t\tif _, err = b.WriteString(p.padding); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\tif _, err = b.WriteString(\"<\" + key); err != nil {\n\t\t\treturn err\n\t\t}\n\t\tendTag, isSimple = true, true\n\t\tbreak\n\tdefault: // handle anything - even goofy stuff\n\t\telen = 0\n\t\tswitch value.(type) {\n\t\tcase string:\n\t\t\tv := value.(string)\n\t\t\tif xmlEscapeChars {\n\t\t\t\tv = escapeChars(v)\n\t\t\t}\n\t\t\telen = len(v)\n\t\t\tif elen > 0 {\n\t\t\t\t// *s += \">\" + v\n\t\t\t\tif _, err = b.WriteString(\">\" + v); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\tcase float64, bool, int, int32, int64, float32, json.Number:\n\t\t\tv := fmt.Sprintf(\"%v\", value)\n\t\t\telen = len(v) // always > 0\n\t\t\tif _, err = b.WriteString(\">\" + v); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\tcase []byte: // NOTE: byte is just an alias for uint8\n\t\t\t// similar to how xml.Marshal handles []byte structure members\n\t\t\tv := string(value.([]byte))\n\t\t\tif xmlEscapeChars {\n\t\t\t\tv = escapeChars(v)\n\t\t\t}\n\t\t\telen = len(v)\n\t\t\tif elen > 0 {\n\t\t\t\t// *s += \">\" + v\n\t\t\t\tif _, err = b.WriteString(\">\" + v); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\tdefault:\n\t\t\tif _, err = b.WriteString(\">\"); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tvar v []byte\n\t\t\tvar err error\n\t\t\tif doIndent {\n\t\t\t\tv, err = xml.MarshalIndent(value, p.padding, p.indent)\n\t\t\t} else {\n\t\t\t\tv, err = xml.Marshal(value)\n\t\t\t}\n\t\t\tif err != nil {\n\t\t\t\tif _, err = b.WriteString(\">UNKNOWN\"); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\telen = len(v)\n\t\t\t\tif elen > 0 {\n\t\t\t\t\tif _, err = b.Write(v); err != nil {\n\t\t\t\t\t\treturn err\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tisSimple = true\n\t\tendTag = true\n\t}\n\tif endTag {\n\t\tif doIndent {\n\t\t\tif !isSimple {\n\t\t\t\tif _, err = b.WriteString(p.padding); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif elen > 0 || useGoXmlEmptyElemSyntax {\n\t\t\tif elen == 0 {\n\t\t\t\tif _, err = b.WriteString(\">\"); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t\tif _, err = b.WriteString(`\"); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t} else {\n\t\t\tif _, err = b.WriteString(`/>`); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t}\n\tif doIndent {\n\t\tif p.cnt > p.start {\n\t\t\tif _, err = b.WriteString(\"\\n\"); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\tp.Outdent()\n\t}\n\n\treturn nil\n}\n\n// ============================ sort interface implementation =================\n\ntype attrList [][2]string\n\nfunc (a attrList) Len() int {\n\treturn len(a)\n}\n\nfunc (a attrList) Swap(i, j int) {\n\ta[i], a[j] = a[j], a[i]\n}\n\nfunc (a attrList) Less(i, j int) bool {\n\treturn a[i][0] <= a[j][0]\n}\n\ntype elemList [][2]interface{}\n\nfunc (e elemList) Len() int {\n\treturn len(e)\n}\n\nfunc (e elemList) Swap(i, j int) {\n\te[i], e[j] = e[j], e[i]\n}\n\nfunc (e elemList) Less(i, j int) bool {\n\treturn e[i][0].(string) <= e[j][0].(string)\n}\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/xmlseq.go",
"content": "// Copyright 2012-2016, 2019 Charles Banning. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file\n\n// xmlseq.go - version of xml.go with sequence # injection on Decoding and sorting on Encoding.\n// Also, handles comments, directives and process instructions.\n\npackage mxj\n\nimport (\n\t\"bytes\"\n\t\"encoding/xml\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"regexp\"\n\t\"sort\"\n\t\"strings\"\n)\n\n// MapSeq is like Map but contains seqencing indices to allow recovering the original order of\n// the XML elements when the map[string]interface{} is marshaled. Element attributes are\n// stored as a map[\"#attr\"]map[]map[string]interface{}{\"#text\":\"\", \"#seq\":}\n// value instead of denoting the keys with a prefix character. Also, comments, directives and\n// process instructions are preserved.\ntype MapSeq map[string]interface{}\n\n// NoRoot is returned by NewXmlSeq, etc., when a comment, directive or procinstr element is parsed\n// in the XML data stream and the element is not contained in an XML object with a root element.\nvar NoRoot = errors.New(\"no root key\")\nvar NO_ROOT = NoRoot // maintain backwards compatibility\n\n// ------------------- NewMapXmlSeq & NewMapXmlSeqReader ... -------------------------\n\n// NewMapXmlSeq converts a XML doc into a MapSeq value with elements id'd with decoding sequence key represented\n// as map[\"#seq\"].\n// If the optional argument 'cast' is 'true', then values will be converted to boolean or float64 if possible.\n// NOTE: \"#seq\" key/value pairs are removed on encoding with msv.Xml() / msv.XmlIndent().\n//\t• attributes are a map - map[\"#attr\"]map[\"attr_key\"]map[string]interface{}{\"#text\":, \"#seq\":}\n//\t• all simple elements are decoded as map[\"#text\"]interface{} with a \"#seq\" k:v pair, as well.\n//\t• lists always decode as map[\"list_tag\"][]map[string]interface{} where the array elements are maps that\n//\t include a \"#seq\" k:v pair based on sequence they are decoded. Thus, XML like:\n//\t \n//\t value 1\n//\t value 2\n//\t value 3\n//\t \n//\t is decoded as:\n//\t doc :\n//\t ltag :[[]interface{}]\n//\t [item: 0]\n//\t #seq :[int] 0\n//\t #text :[string] value 1\n//\t [item: 1]\n//\t #seq :[int] 2\n//\t #text :[string] value 3\n//\t newtag :\n//\t #seq :[int] 1\n//\t #text :[string] value 2\n//\t It will encode in proper sequence even though the MapSeq representation merges all \"ltag\" elements in an array.\n//\t• comments - \"\" - are decoded as map[\"#comment\"]map[\"#text\"]\"cmnt_text\" with a \"#seq\" k:v pair.\n//\t• directives - \"\" - are decoded as map[\"#directive\"]map[#text\"]\"directive_text\" with a \"#seq\" k:v pair.\n//\t• process instructions - \"\" - are decoded as map[\"#procinst\"]interface{} where the #procinst value\n//\t is of map[string]interface{} type with the following keys: #target, #inst, and #seq.\n//\t• comments, directives, and procinsts that are NOT part of a document with a root key will be returned as\n//\t map[string]interface{} and the error value 'NoRoot'.\n//\t• note: \": tag preserve the\n//\t \":\" notation rather than stripping it as with NewMapXml().\n//\t 2. Attribute keys for name space prefix declarations preserve \"xmlns:\" notation.\n//\n//\tERRORS:\n//\t 1. If a NoRoot error, \"no root key,\" is returned, check the initial map key for a \"#comment\",\n//\t \"#directive\" or #procinst\" key.\n//\t 2. Unmarshaling an XML doc that is formatted using the whitespace character, \" \", will error, since\n//\t Decoder.RawToken treats such occurances as significant. See NewMapFormattedXmlSeq().\nfunc NewMapXmlSeq(xmlVal []byte, cast ...bool) (MapSeq, error) {\n\tvar r bool\n\tif len(cast) == 1 {\n\t\tr = cast[0]\n\t}\n\treturn xmlSeqToMap(xmlVal, r)\n}\n\n// NewMapFormattedXmlSeq performs the same as NewMapXmlSeq but is useful for processing XML objects that\n// are formatted using the whitespace character, \" \". (The stdlib xml.Decoder, by default, treats all\n// whitespace as significant; Decoder.Token() and Decoder.RawToken() will return strings of one or more\n// whitespace characters and without alphanumeric or punctuation characters as xml.CharData values.)\n//\n// If you're processing such XML, then this will convert all occurrences of whitespace-only strings\n// into an empty string, \"\", prior to parsing the XML - irrespective of whether the occurrence is\n// formatting or is a actual element value.\nfunc NewMapFormattedXmlSeq(xmlVal []byte, cast ...bool) (MapSeq, error) {\n\tvar c bool\n\tif len(cast) == 1 {\n\t\tc = cast[0]\n\t}\n\n\t// Per PR #104 - clean out formatting characters so they don't show up in Decoder.RawToken() stream.\n\t// NOTE: Also replaces element values that are solely comprised of formatting/whitespace characters\n\t// with empty string, \"\".\n\tr := regexp.MustCompile(`>[\\n\\t\\r ]*<`)\n\txmlVal = r.ReplaceAll(xmlVal, []byte(\"><\"))\n\treturn xmlSeqToMap(xmlVal, c)\n}\n\n// NewMpaXmlSeqReader returns next XML doc from an io.Reader as a MapSeq value.\n//\tNOTES:\n//\t 1. The 'xmlReader' will be parsed looking for an xml.StartElement, xml.Comment, etc., so BOM and other\n//\t extraneous xml.CharData will be ignored unless io.EOF is reached first.\n//\t 2. CoerceKeysToLower() is NOT recognized, since the intent here is to eventually call m.XmlSeq() to\n//\t re-encode the message in its original structure.\n//\t 3. If CoerceKeysToSnakeCase() has been called, then all key values will be converted to snake case.\n//\n//\tERRORS:\n//\t 1. If a NoRoot error, \"no root key,\" is returned, check the initial map key for a \"#comment\",\n//\t \"#directive\" or #procinst\" key.\nfunc NewMapXmlSeqReader(xmlReader io.Reader, cast ...bool) (MapSeq, error) {\n\tvar r bool\n\tif len(cast) == 1 {\n\t\tr = cast[0]\n\t}\n\n\t// We need to put an *os.File reader in a ByteReader or the xml.NewDecoder\n\t// will wrap it in a bufio.Reader and seek on the file beyond where the\n\t// xml.Decoder parses!\n\tif _, ok := xmlReader.(io.ByteReader); !ok {\n\t\txmlReader = myByteReader(xmlReader) // see code at EOF\n\t}\n\n\t// build the map\n\treturn xmlSeqReaderToMap(xmlReader, r)\n}\n\n// NewMapXmlSeqReaderRaw returns the next XML doc from an io.Reader as a MapSeq value.\n// Returns MapSeq value, slice with the raw XML, and any error.\n//\tNOTES:\n//\t 1. Due to the implementation of xml.Decoder, the raw XML off the reader is buffered to []byte\n//\t using a ByteReader. If the io.Reader is an os.File, there may be significant performance impact.\n//\t See the examples - getmetrics1.go through getmetrics4.go - for comparative use cases on a large\n//\t data set. If the io.Reader is wrapping a []byte value in-memory, however, such as http.Request.Body\n//\t you CAN use it to efficiently unmarshal a XML doc and retrieve the raw XML in a single call.\n//\t 2. The 'raw' return value may be larger than the XML text value.\n//\t 3. The 'xmlReader' will be parsed looking for an xml.StartElement, xml.Comment, etc., so BOM and other\n//\t extraneous xml.CharData will be ignored unless io.EOF is reached first.\n//\t 4. CoerceKeysToLower() is NOT recognized, since the intent here is to eventually call m.XmlSeq() to\n//\t re-encode the message in its original structure.\n//\t 5. If CoerceKeysToSnakeCase() has been called, then all key values will be converted to snake case.\n//\n//\tERRORS:\n//\t 1. If a NoRoot error, \"no root key,\" is returned, check if the initial map key is \"#comment\",\n//\t \"#directive\" or #procinst\" key.\nfunc NewMapXmlSeqReaderRaw(xmlReader io.Reader, cast ...bool) (MapSeq, []byte, error) {\n\tvar r bool\n\tif len(cast) == 1 {\n\t\tr = cast[0]\n\t}\n\t// create TeeReader so we can retrieve raw XML\n\tbuf := make([]byte, 0)\n\twb := bytes.NewBuffer(buf)\n\ttrdr := myTeeReader(xmlReader, wb)\n\n\tm, err := xmlSeqReaderToMap(trdr, r)\n\n\t// retrieve the raw XML that was decoded\n\tb := wb.Bytes()\n\n\t// err may be NoRoot\n\treturn m, b, err\n}\n\n// xmlSeqReaderToMap() - parse a XML io.Reader to a map[string]interface{} value\nfunc xmlSeqReaderToMap(rdr io.Reader, r bool) (map[string]interface{}, error) {\n\t// parse the Reader\n\tp := xml.NewDecoder(rdr)\n\tif CustomDecoder != nil {\n\t\tuseCustomDecoder(p)\n\t} else {\n\t\tp.CharsetReader = XmlCharsetReader\n\t}\n\treturn xmlSeqToMapParser(\"\", nil, p, r)\n}\n\n// xmlSeqToMap - convert a XML doc into map[string]interface{} value\nfunc xmlSeqToMap(doc []byte, r bool) (map[string]interface{}, error) {\n\tb := bytes.NewReader(doc)\n\tp := xml.NewDecoder(b)\n\tif CustomDecoder != nil {\n\t\tuseCustomDecoder(p)\n\t} else {\n\t\tp.CharsetReader = XmlCharsetReader\n\t}\n\treturn xmlSeqToMapParser(\"\", nil, p, r)\n}\n\n// ===================================== where the work happens =============================\n\n// xmlSeqToMapParser - load a 'clean' XML doc into a map[string]interface{} directly.\n// Add #seq tag value for each element decoded - to be used for Encoding later.\nfunc xmlSeqToMapParser(skey string, a []xml.Attr, p *xml.Decoder, r bool) (map[string]interface{}, error) {\n\tif snakeCaseKeys {\n\t\tskey = strings.Replace(skey, \"-\", \"_\", -1)\n\t}\n\n\t// NOTE: all attributes and sub-elements parsed into 'na', 'na' is returned as value for 'skey' in 'n'.\n\tvar n, na map[string]interface{}\n\tvar seq int // for including seq num when decoding\n\n\t// Allocate maps and load attributes, if any.\n\t// NOTE: on entry from NewMapXml(), etc., skey==\"\", and we fall through\n\t// to get StartElement then recurse with skey==xml.StartElement.Name.Local\n\t// where we begin allocating map[string]interface{} values 'n' and 'na'.\n\tif skey != \"\" {\n\t\t// 'n' only needs one slot - save call to runtime•hashGrow()\n\t\t// 'na' we don't know\n\t\tn = make(map[string]interface{}, 1)\n\t\tna = make(map[string]interface{})\n\t\tif len(a) > 0 {\n\t\t\t// xml.Attr is decoded into: map[\"#attr\"]map[]interface{}\n\t\t\t// where interface{} is map[string]interface{}{\"#text\":, \"#seq\":}\n\t\t\taa := make(map[string]interface{}, len(a))\n\t\t\tfor i, v := range a {\n\t\t\t\tif snakeCaseKeys {\n\t\t\t\t\tv.Name.Local = strings.Replace(v.Name.Local, \"-\", \"_\", -1)\n\t\t\t\t}\n\t\t\t\tif xmlEscapeCharsDecoder { // per issue#84\n\t\t\t\t\tv.Value = escapeChars(v.Value)\n\t\t\t\t}\n\t\t\t\tif len(v.Name.Space) > 0 {\n\t\t\t\t\taa[v.Name.Space+`:`+v.Name.Local] = map[string]interface{}{textK: cast(v.Value, r, \"\"), seqK: i}\n\t\t\t\t} else {\n\t\t\t\t\taa[v.Name.Local] = map[string]interface{}{textK: cast(v.Value, r, \"\"), seqK: i}\n\t\t\t\t}\n\t\t\t}\n\t\t\tna[attrK] = aa\n\t\t}\n\t}\n\n\t// Return XMPP message.\n\tif handleXMPPStreamTag && skey == \"stream:stream\" {\n\t\tn[skey] = na\n\t\treturn n, nil\n\t}\n\n\tfor {\n\t\tt, err := p.RawToken()\n\t\tif err != nil {\n\t\t\tif err != io.EOF {\n\t\t\t\treturn nil, errors.New(\"xml.Decoder.Token() - \" + err.Error())\n\t\t\t}\n\t\t\treturn nil, err\n\t\t}\n\t\tswitch t.(type) {\n\t\tcase xml.StartElement:\n\t\t\ttt := t.(xml.StartElement)\n\n\t\t\t// First call to xmlSeqToMapParser() doesn't pass xml.StartElement - the map key.\n\t\t\t// So when the loop is first entered, the first token is the root tag along\n\t\t\t// with any attributes, which we process here.\n\t\t\t//\n\t\t\t// Subsequent calls to xmlSeqToMapParser() will pass in tag+attributes for\n\t\t\t// processing before getting the next token which is the element value,\n\t\t\t// which is done above.\n\t\t\tif skey == \"\" {\n\t\t\t\tif len(tt.Name.Space) > 0 {\n\t\t\t\t\treturn xmlSeqToMapParser(tt.Name.Space+`:`+tt.Name.Local, tt.Attr, p, r)\n\t\t\t\t} else {\n\t\t\t\t\treturn xmlSeqToMapParser(tt.Name.Local, tt.Attr, p, r)\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// If not initializing the map, parse the element.\n\t\t\t// len(nn) == 1, necessarily - it is just an 'n'.\n\t\t\tvar nn map[string]interface{}\n\t\t\tif len(tt.Name.Space) > 0 {\n\t\t\t\tnn, err = xmlSeqToMapParser(tt.Name.Space+`:`+tt.Name.Local, tt.Attr, p, r)\n\t\t\t} else {\n\t\t\t\tnn, err = xmlSeqToMapParser(tt.Name.Local, tt.Attr, p, r)\n\t\t\t}\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\t// The nn map[string]interface{} value is a na[nn_key] value.\n\t\t\t// We need to see if nn_key already exists - means we're parsing a list.\n\t\t\t// This may require converting na[nn_key] value into []interface{} type.\n\t\t\t// First, extract the key:val for the map - it's a singleton.\n\t\t\tvar key string\n\t\t\tvar val interface{}\n\t\t\tfor key, val = range nn {\n\t\t\t\tbreak\n\t\t\t}\n\n\t\t\t// add \"#seq\" k:v pair -\n\t\t\t// Sequence number included even in list elements - this should allow us\n\t\t\t// to properly resequence even something goofy like:\n\t\t\t// item 1
\n\t\t\t// item 2\n\t\t\t// item 3
\n\t\t\t// where all the \"list\" subelements are decoded into an array.\n\t\t\tswitch val.(type) {\n\t\t\tcase map[string]interface{}:\n\t\t\t\tval.(map[string]interface{})[seqK] = seq\n\t\t\t\tseq++\n\t\t\tcase interface{}: // a non-nil simple element: string, float64, bool\n\t\t\t\tv := map[string]interface{}{textK: val, seqK: seq}\n\t\t\t\tseq++\n\t\t\t\tval = v\n\t\t\t}\n\n\t\t\t// 'na' holding sub-elements of n.\n\t\t\t// See if 'key' already exists.\n\t\t\t// If 'key' exists, then this is a list, if not just add key:val to na.\n\t\t\tif v, ok := na[key]; ok {\n\t\t\t\tvar a []interface{}\n\t\t\t\tswitch v.(type) {\n\t\t\t\tcase []interface{}:\n\t\t\t\t\ta = v.([]interface{})\n\t\t\t\tdefault: // anything else - note: v.(type) != nil\n\t\t\t\t\ta = []interface{}{v}\n\t\t\t\t}\n\t\t\t\ta = append(a, val)\n\t\t\t\tna[key] = a\n\t\t\t} else {\n\t\t\t\tna[key] = val // save it as a singleton\n\t\t\t}\n\t\tcase xml.EndElement:\n\t\t\tif skey != \"\" {\n\t\t\t\ttt := t.(xml.EndElement)\n\t\t\t\tif snakeCaseKeys {\n\t\t\t\t\ttt.Name.Local = strings.Replace(tt.Name.Local, \"-\", \"_\", -1)\n\t\t\t\t}\n\t\t\t\tvar name string\n\t\t\t\tif len(tt.Name.Space) > 0 {\n\t\t\t\t\tname = tt.Name.Space + `:` + tt.Name.Local\n\t\t\t\t} else {\n\t\t\t\t\tname = tt.Name.Local\n\t\t\t\t}\n\t\t\t\tif skey != name {\n\t\t\t\t\treturn nil, fmt.Errorf(\"element %s not properly terminated, got %s at #%d\",\n\t\t\t\t\t\tskey, name, p.InputOffset())\n\t\t\t\t}\n\t\t\t}\n\t\t\t// len(n) > 0 if this is a simple element w/o xml.Attrs - see xml.CharData case.\n\t\t\tif len(n) == 0 {\n\t\t\t\t// If len(na)==0 we have an empty element == \"\";\n\t\t\t\t// it has no xml.Attr nor xml.CharData.\n\t\t\t\t// Empty element content will be map[\"etag\"]map[\"#text\"]\"\"\n\t\t\t\t// after #seq injection - map[\"etag\"]map[\"#seq\"]seq - after return.\n\t\t\t\tif len(na) > 0 {\n\t\t\t\t\tn[skey] = na\n\t\t\t\t} else {\n\t\t\t\t\tn[skey] = \"\" // empty element\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn n, nil\n\t\tcase xml.CharData:\n\t\t\t// clean up possible noise\n\t\t\ttt := strings.Trim(string(t.(xml.CharData)), trimRunes)\n\t\t\tif xmlEscapeCharsDecoder { // issue#84\n\t\t\t\ttt = escapeChars(tt)\n\t\t\t}\n\t\t\tif skey == \"\" {\n\t\t\t\t// per Adrian (http://www.adrianlungu.com/) catch stray text\n\t\t\t\t// in decoder stream -\n\t\t\t\t// https://github.com/clbanning/mxj/pull/14#issuecomment-182816374\n\t\t\t\t// NOTE: CharSetReader must be set to non-UTF-8 CharSet or you'll get\n\t\t\t\t// a p.Token() decoding error when the BOM is UTF-16 or UTF-32.\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif len(tt) > 0 {\n\t\t\t\t// every simple element is a #text and has #seq associated with it\n\t\t\t\tna[textK] = cast(tt, r, \"\")\n\t\t\t\tna[seqK] = seq\n\t\t\t\tseq++\n\t\t\t}\n\t\tcase xml.Comment:\n\t\t\tif n == nil { // no root 'key'\n\t\t\t\tn = map[string]interface{}{commentK: string(t.(xml.Comment))}\n\t\t\t\treturn n, NoRoot\n\t\t\t}\n\t\t\tcm := make(map[string]interface{}, 2)\n\t\t\tcm[textK] = string(t.(xml.Comment))\n\t\t\tcm[seqK] = seq\n\t\t\tseq++\n\t\t\tna[commentK] = cm\n\t\tcase xml.Directive:\n\t\t\tif n == nil { // no root 'key'\n\t\t\t\tn = map[string]interface{}{directiveK: string(t.(xml.Directive))}\n\t\t\t\treturn n, NoRoot\n\t\t\t}\n\t\t\tdm := make(map[string]interface{}, 2)\n\t\t\tdm[textK] = string(t.(xml.Directive))\n\t\t\tdm[seqK] = seq\n\t\t\tseq++\n\t\t\tna[directiveK] = dm\n\t\tcase xml.ProcInst:\n\t\t\tif n == nil {\n\t\t\t\tna = map[string]interface{}{targetK: t.(xml.ProcInst).Target, instK: string(t.(xml.ProcInst).Inst)}\n\t\t\t\tn = map[string]interface{}{procinstK: na}\n\t\t\t\treturn n, NoRoot\n\t\t\t}\n\t\t\tpm := make(map[string]interface{}, 3)\n\t\t\tpm[targetK] = t.(xml.ProcInst).Target\n\t\t\tpm[instK] = string(t.(xml.ProcInst).Inst)\n\t\t\tpm[seqK] = seq\n\t\t\tseq++\n\t\t\tna[procinstK] = pm\n\t\tdefault:\n\t\t\t// noop - shouldn't ever get here, now, since we handle all token types\n\t\t}\n\t}\n}\n\n// ------------------ END: NewMapXml & NewMapXmlReader -------------------------\n\n// --------------------- mv.XmlSeq & mv.XmlSeqWriter -------------------------\n\n// Xml encodes a MapSeq as XML with elements sorted on #seq. The companion of NewMapXmlSeq().\n// The following rules apply.\n// - The \"#seq\" key value is used to seqence the subelements or attributes only.\n// - The \"#attr\" map key identifies the map of attribute map[string]interface{} values with \"#text\" key.\n// - The \"#comment\" map key identifies a comment in the value \"#text\" map entry - .\n// - The \"#directive\" map key identifies a directive in the value \"#text\" map entry - .\n// - The \"#procinst\" map key identifies a process instruction in the value \"#target\" and \"#inst\"\n// map entries - .\n// - Value type encoding:\n// > string, bool, float64, int, int32, int64, float32: per \"%v\" formating\n// > []bool, []uint8: by casting to string\n// > structures, etc.: handed to xml.Marshal() - if there is an error, the element\n// value is \"UNKNOWN\"\n// - Elements with only attribute values or are null are terminated using \"/>\" unless XmlGoEmptyElemSystax() called.\n// - If len(mv) == 1 and no rootTag is provided, then the map key is used as the root tag, possible.\n// Thus, `{ \"key\":\"value\" }` encodes as \"value\".\nfunc (mv MapSeq) Xml(rootTag ...string) ([]byte, error) {\n\tm := map[string]interface{}(mv)\n\tvar err error\n\ts := new(string)\n\tp := new(pretty) // just a stub\n\n\tif len(m) == 1 && len(rootTag) == 0 {\n\t\tfor key, value := range m {\n\t\t\t// if it's an array, see if all values are map[string]interface{}\n\t\t\t// we force a new root tag if we'll end up with no key:value in the list\n\t\t\t// so: key:[string_val, bool:true] --> string_valtrue\n\t\t\tswitch value.(type) {\n\t\t\tcase []interface{}:\n\t\t\t\tfor _, v := range value.([]interface{}) {\n\t\t\t\t\tswitch v.(type) {\n\t\t\t\t\tcase map[string]interface{}: // noop\n\t\t\t\t\tdefault: // anything else\n\t\t\t\t\t\terr = mapToXmlSeqIndent(false, s, DefaultRootTag, m, p)\n\t\t\t\t\t\tgoto done\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\terr = mapToXmlSeqIndent(false, s, key, value, p)\n\t\t}\n\t} else if len(rootTag) == 1 {\n\t\terr = mapToXmlSeqIndent(false, s, rootTag[0], m, p)\n\t} else {\n\t\terr = mapToXmlSeqIndent(false, s, DefaultRootTag, m, p)\n\t}\ndone:\n\tif xmlCheckIsValid {\n\t\td := xml.NewDecoder(bytes.NewReader([]byte(*s)))\n\t\tfor {\n\t\t\t_, err = d.Token()\n\t\t\tif err == io.EOF {\n\t\t\t\terr = nil\n\t\t\t\tbreak\n\t\t\t} else if err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t}\n\t}\n\treturn []byte(*s), err\n}\n\n// The following implementation is provided only for symmetry with NewMapXmlReader[Raw]\n// The names will also provide a key for the number of return arguments.\n\n// XmlWriter Writes the MapSeq value as XML on the Writer.\n// See MapSeq.Xml() for encoding rules.\nfunc (mv MapSeq) XmlWriter(xmlWriter io.Writer, rootTag ...string) error {\n\tx, err := mv.Xml(rootTag...)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t_, err = xmlWriter.Write(x)\n\treturn err\n}\n\n// XmlWriteRaw writes the MapSeq value as XML on the Writer. []byte is the raw XML that was written.\n// See Map.XmlSeq() for encoding rules.\n/*\nfunc (mv MapSeq) XmlWriterRaw(xmlWriter io.Writer, rootTag ...string) ([]byte, error) {\n\tx, err := mv.Xml(rootTag...)\n\tif err != nil {\n\t\treturn x, err\n\t}\n\n\t_, err = xmlWriter.Write(x)\n\treturn x, err\n}\n*/\n\n// XmlIndentWriter writes the MapSeq value as pretty XML on the Writer.\n// See MapSeq.Xml() for encoding rules.\nfunc (mv MapSeq) XmlIndentWriter(xmlWriter io.Writer, prefix, indent string, rootTag ...string) error {\n\tx, err := mv.XmlIndent(prefix, indent, rootTag...)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t_, err = xmlWriter.Write(x)\n\treturn err\n}\n\n// XmlIndentWriterRaw writes the Map as pretty XML on the Writer. []byte is the raw XML that was written.\n// See Map.XmlSeq() for encoding rules.\n/*\nfunc (mv MapSeq) XmlIndentWriterRaw(xmlWriter io.Writer, prefix, indent string, rootTag ...string) ([]byte, error) {\n\tx, err := mv.XmlSeqIndent(prefix, indent, rootTag...)\n\tif err != nil {\n\t\treturn x, err\n\t}\n\n\t_, err = xmlWriter.Write(x)\n\treturn x, err\n}\n*/\n\n// -------------------- END: mv.Xml & mv.XmlWriter -------------------------------\n\n// ---------------------- XmlSeqIndent ----------------------------\n\n// XmlIndent encodes a map[string]interface{} as a pretty XML string.\n// See MapSeq.XmlSeq() for encoding rules.\nfunc (mv MapSeq) XmlIndent(prefix, indent string, rootTag ...string) ([]byte, error) {\n\tm := map[string]interface{}(mv)\n\n\tvar err error\n\ts := new(string)\n\tp := new(pretty)\n\tp.indent = indent\n\tp.padding = prefix\n\n\tif len(m) == 1 && len(rootTag) == 0 {\n\t\t// this can extract the key for the single map element\n\t\t// use it if it isn't a key for a list\n\t\tfor key, value := range m {\n\t\t\tif _, ok := value.([]interface{}); ok {\n\t\t\t\terr = mapToXmlSeqIndent(true, s, DefaultRootTag, m, p)\n\t\t\t} else {\n\t\t\t\terr = mapToXmlSeqIndent(true, s, key, value, p)\n\t\t\t}\n\t\t}\n\t} else if len(rootTag) == 1 {\n\t\terr = mapToXmlSeqIndent(true, s, rootTag[0], m, p)\n\t} else {\n\t\terr = mapToXmlSeqIndent(true, s, DefaultRootTag, m, p)\n\t}\n\tif xmlCheckIsValid {\n\t\tif _, err = NewMapXml([]byte(*s)); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\td := xml.NewDecoder(bytes.NewReader([]byte(*s)))\n\t\tfor {\n\t\t\t_, err = d.Token()\n\t\t\tif err == io.EOF {\n\t\t\t\terr = nil\n\t\t\t\tbreak\n\t\t\t} else if err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t}\n\t}\n\treturn []byte(*s), err\n}\n\n// where the work actually happens\n// returns an error if an attribute is not atomic\nfunc mapToXmlSeqIndent(doIndent bool, s *string, key string, value interface{}, pp *pretty) error {\n\tvar endTag bool\n\tvar isSimple bool\n\tvar noEndTag bool\n\tvar elen int\n\tvar ss string\n\tp := &pretty{pp.indent, pp.cnt, pp.padding, pp.mapDepth, pp.start}\n\n\tswitch value.(type) {\n\tcase map[string]interface{}, []byte, string, float64, bool, int, int32, int64, float32:\n\t\tif doIndent {\n\t\t\t*s += p.padding\n\t\t}\n\t\tif key != commentK && key != directiveK && key != procinstK {\n\t\t\t*s += `<` + key\n\t\t}\n\t}\n\tswitch value.(type) {\n\tcase map[string]interface{}:\n\t\tval := value.(map[string]interface{})\n\n\t\tif key == commentK {\n\t\t\t*s += ``\n\t\t\tnoEndTag = true\n\t\t\tbreak\n\t\t}\n\n\t\tif key == directiveK {\n\t\t\t*s += ``\n\t\t\tnoEndTag = true\n\t\t\tbreak\n\t\t}\n\n\t\tif key == procinstK {\n\t\t\t*s += ``\n\t\t\tnoEndTag = true\n\t\t\tbreak\n\t\t}\n\n\t\thaveAttrs := false\n\t\t// process attributes first\n\t\tif v, ok := val[attrK].(map[string]interface{}); ok {\n\t\t\t// First, unroll the map[string]interface{} into a []keyval array.\n\t\t\t// Then sequence it.\n\t\t\tkv := make([]keyval, len(v))\n\t\t\tn := 0\n\t\t\tfor ak, av := range v {\n\t\t\t\tkv[n] = keyval{ak, av}\n\t\t\t\tn++\n\t\t\t}\n\t\t\tsort.Sort(elemListSeq(kv))\n\t\t\t// Now encode the attributes in original decoding sequence, using keyval array.\n\t\t\tfor _, a := range kv {\n\t\t\t\tvv := a.v.(map[string]interface{})\n\t\t\t\tswitch vv[textK].(type) {\n\t\t\t\tcase string:\n\t\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\t\tss = escapeChars(vv[textK].(string))\n\t\t\t\t\t} else {\n\t\t\t\t\t\tss = vv[textK].(string)\n\t\t\t\t\t}\n\t\t\t\t\t*s += ` ` + a.k + `=\"` + ss + `\"`\n\t\t\t\tcase float64, bool, int, int32, int64, float32:\n\t\t\t\t\t*s += ` ` + a.k + `=\"` + fmt.Sprintf(\"%v\", vv[textK]) + `\"`\n\t\t\t\tcase []byte:\n\t\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\t\tss = escapeChars(string(vv[textK].([]byte)))\n\t\t\t\t\t} else {\n\t\t\t\t\t\tss = string(vv[textK].([]byte))\n\t\t\t\t\t}\n\t\t\t\t\t*s += ` ` + a.k + `=\"` + ss + `\"`\n\t\t\t\tdefault:\n\t\t\t\t\treturn fmt.Errorf(\"invalid attribute value for: %s\", a.k)\n\t\t\t\t}\n\t\t\t}\n\t\t\thaveAttrs = true\n\t\t}\n\n\t\t// simple element?\n\t\t// every map value has, at least, \"#seq\" and, perhaps, \"#text\" and/or \"#attr\"\n\t\t_, seqOK := val[seqK] // have key\n\t\tif v, ok := val[textK]; ok && ((len(val) == 3 && haveAttrs) || (len(val) == 2 && !haveAttrs)) && seqOK {\n\t\t\tif stmp, ok := v.(string); ok && stmp != \"\" {\n\t\t\t\tif xmlEscapeChars {\n\t\t\t\t\tstmp = escapeChars(stmp)\n\t\t\t\t}\n\t\t\t\t*s += \">\" + stmp\n\t\t\t\tendTag = true\n\t\t\t\telen = 1\n\t\t\t}\n\t\t\tisSimple = true\n\t\t\tbreak\n\t\t} else if !ok && ((len(val) == 2 && haveAttrs) || (len(val) == 1 && !haveAttrs)) && seqOK {\n\t\t\t// here no #text but have #seq or #seq+#attr\n\t\t\tendTag = false\n\t\t\tbreak\n\t\t}\n\n\t\t// we now need to sequence everything except attributes\n\t\t// 'kv' will hold everything that needs to be written\n\t\tkv := make([]keyval, 0)\n\t\tfor k, v := range val {\n\t\t\tif k == attrK { // already processed\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif k == seqK { // ignore - just for sorting\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tswitch v.(type) {\n\t\t\tcase []interface{}:\n\t\t\t\t// unwind the array as separate entries\n\t\t\t\tfor _, vv := range v.([]interface{}) {\n\t\t\t\t\tkv = append(kv, keyval{k, vv})\n\t\t\t\t}\n\t\t\tdefault:\n\t\t\t\tkv = append(kv, keyval{k, v})\n\t\t\t}\n\t\t}\n\n\t\t// close tag with possible attributes\n\t\t*s += \">\"\n\t\tif doIndent {\n\t\t\t*s += \"\\n\"\n\t\t}\n\t\t// something more complex\n\t\tp.mapDepth++\n\t\tsort.Sort(elemListSeq(kv))\n\t\ti := 0\n\t\tfor _, v := range kv {\n\t\t\tswitch v.v.(type) {\n\t\t\tcase []interface{}:\n\t\t\tdefault:\n\t\t\t\tif i == 0 && doIndent {\n\t\t\t\t\tp.Indent()\n\t\t\t\t}\n\t\t\t}\n\t\t\ti++\n\t\t\tif err := mapToXmlSeqIndent(doIndent, s, v.k, v.v, p); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tswitch v.v.(type) {\n\t\t\tcase []interface{}: // handled in []interface{} case\n\t\t\tdefault:\n\t\t\t\tif doIndent {\n\t\t\t\t\tp.Outdent()\n\t\t\t\t}\n\t\t\t}\n\t\t\ti--\n\t\t}\n\t\tp.mapDepth--\n\t\tendTag = true\n\t\telen = 1 // we do have some content other than attrs\n\tcase []interface{}:\n\t\tfor _, v := range value.([]interface{}) {\n\t\t\tif doIndent {\n\t\t\t\tp.Indent()\n\t\t\t}\n\t\t\tif err := mapToXmlSeqIndent(doIndent, s, key, v, p); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tif doIndent {\n\t\t\t\tp.Outdent()\n\t\t\t}\n\t\t}\n\t\treturn nil\n\tcase nil:\n\t\t// terminate the tag\n\t\tif doIndent {\n\t\t\t*s += p.padding\n\t\t}\n\t\t*s += \"<\" + key\n\t\tendTag, isSimple = true, true\n\t\tbreak\n\tdefault: // handle anything - even goofy stuff\n\t\telen = 0\n\t\tswitch value.(type) {\n\t\tcase string:\n\t\t\tif xmlEscapeChars {\n\t\t\t\tss = escapeChars(value.(string))\n\t\t\t} else {\n\t\t\t\tss = value.(string)\n\t\t\t}\n\t\t\telen = len(ss)\n\t\t\tif elen > 0 {\n\t\t\t\t*s += \">\" + ss\n\t\t\t}\n\t\tcase float64, bool, int, int32, int64, float32:\n\t\t\tv := fmt.Sprintf(\"%v\", value)\n\t\t\telen = len(v)\n\t\t\tif elen > 0 {\n\t\t\t\t*s += \">\" + v\n\t\t\t}\n\t\tcase []byte: // NOTE: byte is just an alias for uint8\n\t\t\t// similar to how xml.Marshal handles []byte structure members\n\t\t\tif xmlEscapeChars {\n\t\t\t\tss = escapeChars(string(value.([]byte)))\n\t\t\t} else {\n\t\t\t\tss = string(value.([]byte))\n\t\t\t}\n\t\t\telen = len(ss)\n\t\t\tif elen > 0 {\n\t\t\t\t*s += \">\" + ss\n\t\t\t}\n\t\tdefault:\n\t\t\tvar v []byte\n\t\t\tvar err error\n\t\t\tif doIndent {\n\t\t\t\tv, err = xml.MarshalIndent(value, p.padding, p.indent)\n\t\t\t} else {\n\t\t\t\tv, err = xml.Marshal(value)\n\t\t\t}\n\t\t\tif err != nil {\n\t\t\t\t*s += \">UNKNOWN\"\n\t\t\t} else {\n\t\t\t\telen = len(v)\n\t\t\t\tif elen > 0 {\n\t\t\t\t\t*s += string(v)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tisSimple = true\n\t\tendTag = true\n\t}\n\tif endTag && !noEndTag {\n\t\tif doIndent {\n\t\t\tif !isSimple {\n\t\t\t\t*s += p.padding\n\t\t\t}\n\t\t}\n\t\tswitch value.(type) {\n\t\tcase map[string]interface{}, []byte, string, float64, bool, int, int32, int64, float32:\n\t\t\tif elen > 0 || useGoXmlEmptyElemSyntax {\n\t\t\t\tif elen == 0 {\n\t\t\t\t\t*s += \">\"\n\t\t\t\t}\n\t\t\t\t*s += `\"\n\t\t\t} else {\n\t\t\t\t*s += `/>`\n\t\t\t}\n\t\t}\n\t} else if !noEndTag {\n\t\tif useGoXmlEmptyElemSyntax {\n\t\t\t*s += `\"\n\t\t\t// *s += \">\"\n\t\t} else {\n\t\t\t*s += \"/>\"\n\t\t}\n\t}\n\tif doIndent {\n\t\tif p.cnt > p.start {\n\t\t\t*s += \"\\n\"\n\t\t}\n\t\tp.Outdent()\n\t}\n\n\treturn nil\n}\n\n// the element sort implementation\n\ntype keyval struct {\n\tk string\n\tv interface{}\n}\ntype elemListSeq []keyval\n\nfunc (e elemListSeq) Len() int {\n\treturn len(e)\n}\n\nfunc (e elemListSeq) Swap(i, j int) {\n\te[i], e[j] = e[j], e[i]\n}\n\nfunc (e elemListSeq) Less(i, j int) bool {\n\tvar iseq, jseq int\n\tvar fiseq, fjseq float64\n\tvar ok bool\n\tif iseq, ok = e[i].v.(map[string]interface{})[seqK].(int); !ok {\n\t\tif fiseq, ok = e[i].v.(map[string]interface{})[seqK].(float64); ok {\n\t\t\tiseq = int(fiseq)\n\t\t} else {\n\t\t\tiseq = 9999999\n\t\t}\n\t}\n\n\tif jseq, ok = e[j].v.(map[string]interface{})[seqK].(int); !ok {\n\t\tif fjseq, ok = e[j].v.(map[string]interface{})[seqK].(float64); ok {\n\t\t\tjseq = int(fjseq)\n\t\t} else {\n\t\t\tjseq = 9999999\n\t\t}\n\t}\n\n\treturn iseq <= jseq\n}\n\n// =============== https://groups.google.com/forum/#!topic/golang-nuts/lHPOHD-8qio\n\n// BeautifyXml (re)formats an XML doc similar to Map.XmlIndent().\n// It preserves comments, directives and process instructions,\nfunc BeautifyXml(b []byte, prefix, indent string) ([]byte, error) {\n\tx, err := NewMapXmlSeq(b)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn x.XmlIndent(prefix, indent)\n}\n"
},
{
"path": "vendor/github.com/clbanning/mxj/v2/xmlseq2.go",
"content": "// Copyright 2012-2016, 2019 Charles Banning. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file\n\npackage mxj\n\n// ---------------- expose Map methods to MapSeq type ---------------------------\n\n// Pretty print a Map.\nfunc (msv MapSeq) StringIndent(offset ...int) string {\n\treturn writeMap(map[string]interface{}(msv), true, true, offset...)\n}\n\n// Pretty print a Map without the value type information - just key:value entries.\nfunc (msv MapSeq) StringIndentNoTypeInfo(offset ...int) string {\n\treturn writeMap(map[string]interface{}(msv), false, true, offset...)\n}\n\n"
},
{
"path": "vendor/github.com/coreos/go-systemd/v22/LICENSE",
"content": "Apache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n\"License\" shall mean the terms and conditions for use, reproduction, and\ndistribution as defined by Sections 1 through 9 of this document.\n\n\"Licensor\" shall mean the copyright owner or entity authorized by the copyright\nowner that is granting the License.\n\n\"Legal Entity\" shall mean the union of the acting entity and all other entities\nthat control, are controlled by, or are under common control with that entity.\nFor the purposes of this definition, \"control\" means (i) the power, direct or\nindirect, to cause the direction or management of such entity, whether by\ncontract or otherwise, or (ii) ownership of fifty percent (50%) or more of the\noutstanding shares, or (iii) beneficial ownership of such entity.\n\n\"You\" (or \"Your\") shall mean an individual or Legal Entity exercising\npermissions granted by this License.\n\n\"Source\" form shall mean the preferred form for making modifications, including\nbut not limited to software source code, documentation source, and configuration\nfiles.\n\n\"Object\" form shall mean any form resulting from mechanical transformation or\ntranslation of a Source form, including but not limited to compiled object code,\ngenerated documentation, and conversions to other media types.\n\n\"Work\" shall mean the work of authorship, whether in Source or Object form, made\navailable under the License, as indicated by a copyright notice that is included\nin or attached to the work (an example is provided in the Appendix below).\n\n\"Derivative Works\" shall mean any work, whether in Source or Object form, that\nis based on (or derived from) the Work and for which the editorial revisions,\nannotations, elaborations, or other modifications represent, as a whole, an\noriginal work of authorship. For the purposes of this License, Derivative Works\nshall not include works that remain separable from, or merely link (or bind by\nname) to the interfaces of, the Work and Derivative Works thereof.\n\n\"Contribution\" shall mean any work of authorship, including the original version\nof the Work and any modifications or additions to that Work or Derivative Works\nthereof, that is intentionally submitted to Licensor for inclusion in the Work\nby the copyright owner or by an individual or Legal Entity authorized to submit\non behalf of the copyright owner. For the purposes of this definition,\n\"submitted\" means any form of electronic, verbal, or written communication sent\nto the Licensor or its representatives, including but not limited to\ncommunication on electronic mailing lists, source code control systems, and\nissue tracking systems that are managed by, or on behalf of, the Licensor for\nthe purpose of discussing and improving the Work, but excluding communication\nthat is conspicuously marked or otherwise designated in writing by the copyright\nowner as \"Not a Contribution.\"\n\n\"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf\nof whom a Contribution has been received by Licensor and subsequently\nincorporated within the Work.\n\n2. Grant of Copyright License.\n\nSubject to the terms and conditions of this License, each Contributor hereby\ngrants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,\nirrevocable copyright license to reproduce, prepare Derivative Works of,\npublicly display, publicly perform, sublicense, and distribute the Work and such\nDerivative Works in Source or Object form.\n\n3. Grant of Patent License.\n\nSubject to the terms and conditions of this License, each Contributor hereby\ngrants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,\nirrevocable (except as stated in this section) patent license to make, have\nmade, use, offer to sell, sell, import, and otherwise transfer the Work, where\nsuch license applies only to those patent claims licensable by such Contributor\nthat are necessarily infringed by their Contribution(s) alone or by combination\nof their Contribution(s) with the Work to which such Contribution(s) was\nsubmitted. If You institute patent litigation against any entity (including a\ncross-claim or counterclaim in a lawsuit) alleging that the Work or a\nContribution incorporated within the Work constitutes direct or contributory\npatent infringement, then any patent licenses granted to You under this License\nfor that Work shall terminate as of the date such litigation is filed.\n\n4. Redistribution.\n\nYou may reproduce and distribute copies of the Work or Derivative Works thereof\nin any medium, with or without modifications, and in Source or Object form,\nprovided that You meet the following conditions:\n\nYou must give any other recipients of the Work or Derivative Works a copy of\nthis License; and\nYou must cause any modified files to carry prominent notices stating that You\nchanged the files; and\nYou must retain, in the Source form of any Derivative Works that You distribute,\nall copyright, patent, trademark, and attribution notices from the Source form\nof the Work, excluding those notices that do not pertain to any part of the\nDerivative Works; and\nIf the Work includes a \"NOTICE\" text file as part of its distribution, then any\nDerivative Works that You distribute must include a readable copy of the\nattribution notices contained within such NOTICE file, excluding those notices\nthat do not pertain to any part of the Derivative Works, in at least one of the\nfollowing places: within a NOTICE text file distributed as part of the\nDerivative Works; within the Source form or documentation, if provided along\nwith the Derivative Works; or, within a display generated by the Derivative\nWorks, if and wherever such third-party notices normally appear. The contents of\nthe NOTICE file are for informational purposes only and do not modify the\nLicense. You may add Your own attribution notices within Derivative Works that\nYou distribute, alongside or as an addendum to the NOTICE text from the Work,\nprovided that such additional attribution notices cannot be construed as\nmodifying the License.\nYou may add Your own copyright statement to Your modifications and may provide\nadditional or different license terms and conditions for use, reproduction, or\ndistribution of Your modifications, or for any such Derivative Works as a whole,\nprovided Your use, reproduction, and distribution of the Work otherwise complies\nwith the conditions stated in this License.\n\n5. Submission of Contributions.\n\nUnless You explicitly state otherwise, any Contribution intentionally submitted\nfor inclusion in the Work by You to the Licensor shall be under the terms and\nconditions of this License, without any additional terms or conditions.\nNotwithstanding the above, nothing herein shall supersede or modify the terms of\nany separate license agreement you may have executed with Licensor regarding\nsuch Contributions.\n\n6. Trademarks.\n\nThis License does not grant permission to use the trade names, trademarks,\nservice marks, or product names of the Licensor, except as required for\nreasonable and customary use in describing the origin of the Work and\nreproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty.\n\nUnless required by applicable law or agreed to in writing, Licensor provides the\nWork (and each Contributor provides its Contributions) on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,\nincluding, without limitation, any warranties or conditions of TITLE,\nNON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are\nsolely responsible for determining the appropriateness of using or\nredistributing the Work and assume any risks associated with Your exercise of\npermissions under this License.\n\n8. Limitation of Liability.\n\nIn no event and under no legal theory, whether in tort (including negligence),\ncontract, or otherwise, unless required by applicable law (such as deliberate\nand grossly negligent acts) or agreed to in writing, shall any Contributor be\nliable to You for damages, including any direct, indirect, special, incidental,\nor consequential damages of any character arising as a result of this License or\nout of the use or inability to use the Work (including but not limited to\ndamages for loss of goodwill, work stoppage, computer failure or malfunction, or\nany and all other commercial damages or losses), even if such Contributor has\nbeen advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability.\n\nWhile redistributing the Work or Derivative Works thereof, You may choose to\noffer, and charge a fee for, acceptance of support, warranty, indemnity, or\nother liability obligations and/or rights consistent with this License. However,\nin accepting such obligations, You may act only on Your own behalf and on Your\nsole responsibility, not on behalf of any other Contributor, and only if You\nagree to indemnify, defend, and hold each Contributor harmless for any liability\nincurred by, or claims asserted against, such Contributor by reason of your\naccepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work\n\nTo apply the Apache License to your work, attach the following boilerplate\nnotice, with the fields enclosed by brackets \"[]\" replaced with your own\nidentifying information. (Don't include the brackets!) The text should be\nenclosed in the appropriate comment syntax for the file format. We also\nrecommend that a file or class name and description of purpose be included on\nthe same \"printed page\" as the copyright notice for easier identification within\nthird-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n"
},
{
"path": "vendor/github.com/coreos/go-systemd/v22/NOTICE",
"content": "CoreOS Project\nCopyright 2018 CoreOS, Inc\n\nThis product includes software developed at CoreOS, Inc.\n(http://www.coreos.com/).\n"
},
{
"path": "vendor/github.com/coreos/go-systemd/v22/activation/files_unix.go",
"content": "// Copyright 2015 CoreOS, Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\n//go:build !windows\n// +build !windows\n\n// Package activation implements primitives for systemd socket activation.\npackage activation\n\nimport (\n\t\"os\"\n\t\"strconv\"\n\t\"strings\"\n\t\"syscall\"\n)\n\nconst (\n\t// listenFdsStart corresponds to `SD_LISTEN_FDS_START`.\n\tlistenFdsStart = 3\n)\n\n// Files returns a slice containing a `os.File` object for each\n// file descriptor passed to this process via systemd fd-passing protocol.\n//\n// The order of the file descriptors is preserved in the returned slice.\n// `unsetEnv` is typically set to `true` in order to avoid clashes in\n// fd usage and to avoid leaking environment flags to child processes.\nfunc Files(unsetEnv bool) []*os.File {\n\tif unsetEnv {\n\t\tdefer os.Unsetenv(\"LISTEN_PID\")\n\t\tdefer os.Unsetenv(\"LISTEN_FDS\")\n\t\tdefer os.Unsetenv(\"LISTEN_FDNAMES\")\n\t}\n\n\tpid, err := strconv.Atoi(os.Getenv(\"LISTEN_PID\"))\n\tif err != nil || pid != os.Getpid() {\n\t\treturn nil\n\t}\n\n\tnfds, err := strconv.Atoi(os.Getenv(\"LISTEN_FDS\"))\n\tif err != nil || nfds == 0 {\n\t\treturn nil\n\t}\n\n\tnames := strings.Split(os.Getenv(\"LISTEN_FDNAMES\"), \":\")\n\n\tfiles := make([]*os.File, 0, nfds)\n\tfor fd := listenFdsStart; fd < listenFdsStart+nfds; fd++ {\n\t\tsyscall.CloseOnExec(fd)\n\t\tname := \"LISTEN_FD_\" + strconv.Itoa(fd)\n\t\toffset := fd - listenFdsStart\n\t\tif offset < len(names) && len(names[offset]) > 0 {\n\t\t\tname = names[offset]\n\t\t}\n\t\tfiles = append(files, os.NewFile(uintptr(fd), name))\n\t}\n\n\treturn files\n}\n"
},
{
"path": "vendor/github.com/coreos/go-systemd/v22/activation/files_windows.go",
"content": "// Copyright 2015 CoreOS, Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage activation\n\nimport \"os\"\n\nfunc Files(unsetEnv bool) []*os.File {\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/coreos/go-systemd/v22/activation/listeners.go",
"content": "// Copyright 2015 CoreOS, Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage activation\n\nimport (\n\t\"crypto/tls\"\n\t\"net\"\n)\n\n// Listeners returns a slice containing a net.Listener for each matching socket type\n// passed to this process.\n//\n// The order of the file descriptors is preserved in the returned slice.\n// Nil values are used to fill any gaps. For example if systemd were to return file descriptors\n// corresponding with \"udp, tcp, tcp\", then the slice would contain {nil, net.Listener, net.Listener}\nfunc Listeners() ([]net.Listener, error) {\n\tfiles := Files(true)\n\tlisteners := make([]net.Listener, len(files))\n\n\tfor i, f := range files {\n\t\tif pc, err := net.FileListener(f); err == nil {\n\t\t\tlisteners[i] = pc\n\t\t\tf.Close()\n\t\t}\n\t}\n\treturn listeners, nil\n}\n\n// ListenersWithNames maps a listener name to a set of net.Listener instances.\nfunc ListenersWithNames() (map[string][]net.Listener, error) {\n\tfiles := Files(true)\n\tlisteners := map[string][]net.Listener{}\n\n\tfor _, f := range files {\n\t\tif pc, err := net.FileListener(f); err == nil {\n\t\t\tcurrent, ok := listeners[f.Name()]\n\t\t\tif !ok {\n\t\t\t\tlisteners[f.Name()] = []net.Listener{pc}\n\t\t\t} else {\n\t\t\t\tlisteners[f.Name()] = append(current, pc)\n\t\t\t}\n\t\t\tf.Close()\n\t\t}\n\t}\n\treturn listeners, nil\n}\n\n// TLSListeners returns a slice containing a net.listener for each matching TCP socket type\n// passed to this process.\n// It uses default Listeners func and forces TCP sockets handlers to use TLS based on tlsConfig.\nfunc TLSListeners(tlsConfig *tls.Config) ([]net.Listener, error) {\n\tlisteners, err := Listeners()\n\n\tif listeners == nil || err != nil {\n\t\treturn nil, err\n\t}\n\n\tif tlsConfig != nil {\n\t\tfor i, l := range listeners {\n\t\t\t// Activate TLS only for TCP sockets\n\t\t\tif l.Addr().Network() == \"tcp\" {\n\t\t\t\tlisteners[i] = tls.NewListener(l, tlsConfig)\n\t\t\t}\n\t\t}\n\t}\n\n\treturn listeners, err\n}\n\n// TLSListenersWithNames maps a listener name to a net.Listener with\n// the associated TLS configuration.\nfunc TLSListenersWithNames(tlsConfig *tls.Config) (map[string][]net.Listener, error) {\n\tlisteners, err := ListenersWithNames()\n\n\tif listeners == nil || err != nil {\n\t\treturn nil, err\n\t}\n\n\tif tlsConfig != nil {\n\t\tfor _, ll := range listeners {\n\t\t\t// Activate TLS only for TCP sockets\n\t\t\tfor i, l := range ll {\n\t\t\t\tif l.Addr().Network() == \"tcp\" {\n\t\t\t\t\tll[i] = tls.NewListener(l, tlsConfig)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn listeners, err\n}\n"
},
{
"path": "vendor/github.com/coreos/go-systemd/v22/activation/packetconns.go",
"content": "// Copyright 2015 CoreOS, Inc.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n\npackage activation\n\nimport (\n\t\"net\"\n)\n\n// PacketConns returns a slice containing a net.PacketConn for each matching socket type\n// passed to this process.\n//\n// The order of the file descriptors is preserved in the returned slice.\n// Nil values are used to fill any gaps. For example if systemd were to return file descriptors\n// corresponding with \"udp, tcp, udp\", then the slice would contain {net.PacketConn, nil, net.PacketConn}\nfunc PacketConns() ([]net.PacketConn, error) {\n\tfiles := Files(true)\n\tconns := make([]net.PacketConn, len(files))\n\n\tfor i, f := range files {\n\t\tif pc, err := net.FilePacketConn(f); err == nil {\n\t\t\tconns[i] = pc\n\t\t\tf.Close()\n\t\t}\n\t}\n\treturn conns, nil\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/.travis.yml",
"content": "sudo: false\nlanguage: go\ngo_import_path: github.com/dustin/go-humanize\ngo:\n - 1.13.x\n - 1.14.x\n - 1.15.x\n - 1.16.x\n - stable\n - master\nmatrix:\n allow_failures:\n - go: master\n fast_finish: true\ninstall:\n - # Do nothing. This is needed to prevent default install action \"go get -t -v ./...\" from happening here (we want it to happen inside script step).\nscript:\n - diff -u <(echo -n) <(gofmt -d -s .)\n - go vet .\n - go install -v -race ./...\n - go test -v -race ./...\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/LICENSE",
"content": "Copyright (c) 2005-2008 Dustin Sallings \n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/README.markdown",
"content": "# Humane Units [](https://travis-ci.org/dustin/go-humanize) [](https://godoc.org/github.com/dustin/go-humanize)\n\nJust a few functions for helping humanize times and sizes.\n\n`go get` it as `github.com/dustin/go-humanize`, import it as\n`\"github.com/dustin/go-humanize\"`, use it as `humanize`.\n\nSee [godoc](https://pkg.go.dev/github.com/dustin/go-humanize) for\ncomplete documentation.\n\n## Sizes\n\nThis lets you take numbers like `82854982` and convert them to useful\nstrings like, `83 MB` or `79 MiB` (whichever you prefer).\n\nExample:\n\n```go\nfmt.Printf(\"That file is %s.\", humanize.Bytes(82854982)) // That file is 83 MB.\n```\n\n## Times\n\nThis lets you take a `time.Time` and spit it out in relative terms.\nFor example, `12 seconds ago` or `3 days from now`.\n\nExample:\n\n```go\nfmt.Printf(\"This was touched %s.\", humanize.Time(someTimeInstance)) // This was touched 7 hours ago.\n```\n\nThanks to Kyle Lemons for the time implementation from an IRC\nconversation one day. It's pretty neat.\n\n## Ordinals\n\nFrom a [mailing list discussion][odisc] where a user wanted to be able\nto label ordinals.\n\n 0 -> 0th\n 1 -> 1st\n 2 -> 2nd\n 3 -> 3rd\n 4 -> 4th\n [...]\n\nExample:\n\n```go\nfmt.Printf(\"You're my %s best friend.\", humanize.Ordinal(193)) // You are my 193rd best friend.\n```\n\n## Commas\n\nWant to shove commas into numbers? Be my guest.\n\n 0 -> 0\n 100 -> 100\n 1000 -> 1,000\n 1000000000 -> 1,000,000,000\n -100000 -> -100,000\n\nExample:\n\n```go\nfmt.Printf(\"You owe $%s.\\n\", humanize.Comma(6582491)) // You owe $6,582,491.\n```\n\n## Ftoa\n\nNicer float64 formatter that removes trailing zeros.\n\n```go\nfmt.Printf(\"%f\", 2.24) // 2.240000\nfmt.Printf(\"%s\", humanize.Ftoa(2.24)) // 2.24\nfmt.Printf(\"%f\", 2.0) // 2.000000\nfmt.Printf(\"%s\", humanize.Ftoa(2.0)) // 2\n```\n\n## SI notation\n\nFormat numbers with [SI notation][sinotation].\n\nExample:\n\n```go\nhumanize.SI(0.00000000223, \"M\") // 2.23 nM\n```\n\n## English-specific functions\n\nThe following functions are in the `humanize/english` subpackage.\n\n### Plurals\n\nSimple English pluralization\n\n```go\nenglish.PluralWord(1, \"object\", \"\") // object\nenglish.PluralWord(42, \"object\", \"\") // objects\nenglish.PluralWord(2, \"bus\", \"\") // buses\nenglish.PluralWord(99, \"locus\", \"loci\") // loci\n\nenglish.Plural(1, \"object\", \"\") // 1 object\nenglish.Plural(42, \"object\", \"\") // 42 objects\nenglish.Plural(2, \"bus\", \"\") // 2 buses\nenglish.Plural(99, \"locus\", \"loci\") // 99 loci\n```\n\n### Word series\n\nFormat comma-separated words lists with conjuctions:\n\n```go\nenglish.WordSeries([]string{\"foo\"}, \"and\") // foo\nenglish.WordSeries([]string{\"foo\", \"bar\"}, \"and\") // foo and bar\nenglish.WordSeries([]string{\"foo\", \"bar\", \"baz\"}, \"and\") // foo, bar and baz\n\nenglish.OxfordWordSeries([]string{\"foo\", \"bar\", \"baz\"}, \"and\") // foo, bar, and baz\n```\n\n[odisc]: https://groups.google.com/d/topic/golang-nuts/l8NhI74jl-4/discussion\n[sinotation]: http://en.wikipedia.org/wiki/Metric_prefix\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/big.go",
"content": "package humanize\n\nimport (\n\t\"math/big\"\n)\n\n// order of magnitude (to a max order)\nfunc oomm(n, b *big.Int, maxmag int) (float64, int) {\n\tmag := 0\n\tm := &big.Int{}\n\tfor n.Cmp(b) >= 0 {\n\t\tn.DivMod(n, b, m)\n\t\tmag++\n\t\tif mag == maxmag && maxmag >= 0 {\n\t\t\tbreak\n\t\t}\n\t}\n\treturn float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag\n}\n\n// total order of magnitude\n// (same as above, but with no upper limit)\nfunc oom(n, b *big.Int) (float64, int) {\n\tmag := 0\n\tm := &big.Int{}\n\tfor n.Cmp(b) >= 0 {\n\t\tn.DivMod(n, b, m)\n\t\tmag++\n\t}\n\treturn float64(n.Int64()) + (float64(m.Int64()) / float64(b.Int64())), mag\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/bigbytes.go",
"content": "package humanize\n\nimport (\n\t\"fmt\"\n\t\"math/big\"\n\t\"strings\"\n\t\"unicode\"\n)\n\nvar (\n\tbigIECExp = big.NewInt(1024)\n\n\t// BigByte is one byte in bit.Ints\n\tBigByte = big.NewInt(1)\n\t// BigKiByte is 1,024 bytes in bit.Ints\n\tBigKiByte = (&big.Int{}).Mul(BigByte, bigIECExp)\n\t// BigMiByte is 1,024 k bytes in bit.Ints\n\tBigMiByte = (&big.Int{}).Mul(BigKiByte, bigIECExp)\n\t// BigGiByte is 1,024 m bytes in bit.Ints\n\tBigGiByte = (&big.Int{}).Mul(BigMiByte, bigIECExp)\n\t// BigTiByte is 1,024 g bytes in bit.Ints\n\tBigTiByte = (&big.Int{}).Mul(BigGiByte, bigIECExp)\n\t// BigPiByte is 1,024 t bytes in bit.Ints\n\tBigPiByte = (&big.Int{}).Mul(BigTiByte, bigIECExp)\n\t// BigEiByte is 1,024 p bytes in bit.Ints\n\tBigEiByte = (&big.Int{}).Mul(BigPiByte, bigIECExp)\n\t// BigZiByte is 1,024 e bytes in bit.Ints\n\tBigZiByte = (&big.Int{}).Mul(BigEiByte, bigIECExp)\n\t// BigYiByte is 1,024 z bytes in bit.Ints\n\tBigYiByte = (&big.Int{}).Mul(BigZiByte, bigIECExp)\n\t// BigRiByte is 1,024 y bytes in bit.Ints\n\tBigRiByte = (&big.Int{}).Mul(BigYiByte, bigIECExp)\n\t// BigQiByte is 1,024 r bytes in bit.Ints\n\tBigQiByte = (&big.Int{}).Mul(BigRiByte, bigIECExp)\n)\n\nvar (\n\tbigSIExp = big.NewInt(1000)\n\n\t// BigSIByte is one SI byte in big.Ints\n\tBigSIByte = big.NewInt(1)\n\t// BigKByte is 1,000 SI bytes in big.Ints\n\tBigKByte = (&big.Int{}).Mul(BigSIByte, bigSIExp)\n\t// BigMByte is 1,000 SI k bytes in big.Ints\n\tBigMByte = (&big.Int{}).Mul(BigKByte, bigSIExp)\n\t// BigGByte is 1,000 SI m bytes in big.Ints\n\tBigGByte = (&big.Int{}).Mul(BigMByte, bigSIExp)\n\t// BigTByte is 1,000 SI g bytes in big.Ints\n\tBigTByte = (&big.Int{}).Mul(BigGByte, bigSIExp)\n\t// BigPByte is 1,000 SI t bytes in big.Ints\n\tBigPByte = (&big.Int{}).Mul(BigTByte, bigSIExp)\n\t// BigEByte is 1,000 SI p bytes in big.Ints\n\tBigEByte = (&big.Int{}).Mul(BigPByte, bigSIExp)\n\t// BigZByte is 1,000 SI e bytes in big.Ints\n\tBigZByte = (&big.Int{}).Mul(BigEByte, bigSIExp)\n\t// BigYByte is 1,000 SI z bytes in big.Ints\n\tBigYByte = (&big.Int{}).Mul(BigZByte, bigSIExp)\n\t// BigRByte is 1,000 SI y bytes in big.Ints\n\tBigRByte = (&big.Int{}).Mul(BigYByte, bigSIExp)\n\t// BigQByte is 1,000 SI r bytes in big.Ints\n\tBigQByte = (&big.Int{}).Mul(BigRByte, bigSIExp)\n)\n\nvar bigBytesSizeTable = map[string]*big.Int{\n\t\"b\": BigByte,\n\t\"kib\": BigKiByte,\n\t\"kb\": BigKByte,\n\t\"mib\": BigMiByte,\n\t\"mb\": BigMByte,\n\t\"gib\": BigGiByte,\n\t\"gb\": BigGByte,\n\t\"tib\": BigTiByte,\n\t\"tb\": BigTByte,\n\t\"pib\": BigPiByte,\n\t\"pb\": BigPByte,\n\t\"eib\": BigEiByte,\n\t\"eb\": BigEByte,\n\t\"zib\": BigZiByte,\n\t\"zb\": BigZByte,\n\t\"yib\": BigYiByte,\n\t\"yb\": BigYByte,\n\t\"rib\": BigRiByte,\n\t\"rb\": BigRByte,\n\t\"qib\": BigQiByte,\n\t\"qb\": BigQByte,\n\t// Without suffix\n\t\"\": BigByte,\n\t\"ki\": BigKiByte,\n\t\"k\": BigKByte,\n\t\"mi\": BigMiByte,\n\t\"m\": BigMByte,\n\t\"gi\": BigGiByte,\n\t\"g\": BigGByte,\n\t\"ti\": BigTiByte,\n\t\"t\": BigTByte,\n\t\"pi\": BigPiByte,\n\t\"p\": BigPByte,\n\t\"ei\": BigEiByte,\n\t\"e\": BigEByte,\n\t\"z\": BigZByte,\n\t\"zi\": BigZiByte,\n\t\"y\": BigYByte,\n\t\"yi\": BigYiByte,\n\t\"r\": BigRByte,\n\t\"ri\": BigRiByte,\n\t\"q\": BigQByte,\n\t\"qi\": BigQiByte,\n}\n\nvar ten = big.NewInt(10)\n\nfunc humanateBigBytes(s, base *big.Int, sizes []string) string {\n\tif s.Cmp(ten) < 0 {\n\t\treturn fmt.Sprintf(\"%d B\", s)\n\t}\n\tc := (&big.Int{}).Set(s)\n\tval, mag := oomm(c, base, len(sizes)-1)\n\tsuffix := sizes[mag]\n\tf := \"%.0f %s\"\n\tif val < 10 {\n\t\tf = \"%.1f %s\"\n\t}\n\n\treturn fmt.Sprintf(f, val, suffix)\n\n}\n\n// BigBytes produces a human readable representation of an SI size.\n//\n// See also: ParseBigBytes.\n//\n// BigBytes(82854982) -> 83 MB\nfunc BigBytes(s *big.Int) string {\n\tsizes := []string{\"B\", \"kB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\", \"RB\", \"QB\"}\n\treturn humanateBigBytes(s, bigSIExp, sizes)\n}\n\n// BigIBytes produces a human readable representation of an IEC size.\n//\n// See also: ParseBigBytes.\n//\n// BigIBytes(82854982) -> 79 MiB\nfunc BigIBytes(s *big.Int) string {\n\tsizes := []string{\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\", \"PiB\", \"EiB\", \"ZiB\", \"YiB\", \"RiB\", \"QiB\"}\n\treturn humanateBigBytes(s, bigIECExp, sizes)\n}\n\n// ParseBigBytes parses a string representation of bytes into the number\n// of bytes it represents.\n//\n// See also: BigBytes, BigIBytes.\n//\n// ParseBigBytes(\"42 MB\") -> 42000000, nil\n// ParseBigBytes(\"42 mib\") -> 44040192, nil\nfunc ParseBigBytes(s string) (*big.Int, error) {\n\tlastDigit := 0\n\thasComma := false\n\tfor _, r := range s {\n\t\tif !(unicode.IsDigit(r) || r == '.' || r == ',') {\n\t\t\tbreak\n\t\t}\n\t\tif r == ',' {\n\t\t\thasComma = true\n\t\t}\n\t\tlastDigit++\n\t}\n\n\tnum := s[:lastDigit]\n\tif hasComma {\n\t\tnum = strings.Replace(num, \",\", \"\", -1)\n\t}\n\n\tval := &big.Rat{}\n\t_, err := fmt.Sscanf(num, \"%f\", val)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\textra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))\n\tif m, ok := bigBytesSizeTable[extra]; ok {\n\t\tmv := (&big.Rat{}).SetInt(m)\n\t\tval.Mul(val, mv)\n\t\trv := &big.Int{}\n\t\trv.Div(val.Num(), val.Denom())\n\t\treturn rv, nil\n\t}\n\n\treturn nil, fmt.Errorf(\"unhandled size name: %v\", extra)\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/bytes.go",
"content": "package humanize\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"strconv\"\n\t\"strings\"\n\t\"unicode\"\n)\n\n// IEC Sizes.\n// kibis of bits\nconst (\n\tByte = 1 << (iota * 10)\n\tKiByte\n\tMiByte\n\tGiByte\n\tTiByte\n\tPiByte\n\tEiByte\n)\n\n// SI Sizes.\nconst (\n\tIByte = 1\n\tKByte = IByte * 1000\n\tMByte = KByte * 1000\n\tGByte = MByte * 1000\n\tTByte = GByte * 1000\n\tPByte = TByte * 1000\n\tEByte = PByte * 1000\n)\n\nvar bytesSizeTable = map[string]uint64{\n\t\"b\": Byte,\n\t\"kib\": KiByte,\n\t\"kb\": KByte,\n\t\"mib\": MiByte,\n\t\"mb\": MByte,\n\t\"gib\": GiByte,\n\t\"gb\": GByte,\n\t\"tib\": TiByte,\n\t\"tb\": TByte,\n\t\"pib\": PiByte,\n\t\"pb\": PByte,\n\t\"eib\": EiByte,\n\t\"eb\": EByte,\n\t// Without suffix\n\t\"\": Byte,\n\t\"ki\": KiByte,\n\t\"k\": KByte,\n\t\"mi\": MiByte,\n\t\"m\": MByte,\n\t\"gi\": GiByte,\n\t\"g\": GByte,\n\t\"ti\": TiByte,\n\t\"t\": TByte,\n\t\"pi\": PiByte,\n\t\"p\": PByte,\n\t\"ei\": EiByte,\n\t\"e\": EByte,\n}\n\nfunc logn(n, b float64) float64 {\n\treturn math.Log(n) / math.Log(b)\n}\n\nfunc humanateBytes(s uint64, base float64, sizes []string) string {\n\tif s < 10 {\n\t\treturn fmt.Sprintf(\"%d B\", s)\n\t}\n\te := math.Floor(logn(float64(s), base))\n\tsuffix := sizes[int(e)]\n\tval := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10\n\tf := \"%.0f %s\"\n\tif val < 10 {\n\t\tf = \"%.1f %s\"\n\t}\n\n\treturn fmt.Sprintf(f, val, suffix)\n}\n\n// Bytes produces a human readable representation of an SI size.\n//\n// See also: ParseBytes.\n//\n// Bytes(82854982) -> 83 MB\nfunc Bytes(s uint64) string {\n\tsizes := []string{\"B\", \"kB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\"}\n\treturn humanateBytes(s, 1000, sizes)\n}\n\n// IBytes produces a human readable representation of an IEC size.\n//\n// See also: ParseBytes.\n//\n// IBytes(82854982) -> 79 MiB\nfunc IBytes(s uint64) string {\n\tsizes := []string{\"B\", \"KiB\", \"MiB\", \"GiB\", \"TiB\", \"PiB\", \"EiB\"}\n\treturn humanateBytes(s, 1024, sizes)\n}\n\n// ParseBytes parses a string representation of bytes into the number\n// of bytes it represents.\n//\n// See Also: Bytes, IBytes.\n//\n// ParseBytes(\"42 MB\") -> 42000000, nil\n// ParseBytes(\"42 mib\") -> 44040192, nil\nfunc ParseBytes(s string) (uint64, error) {\n\tlastDigit := 0\n\thasComma := false\n\tfor _, r := range s {\n\t\tif !(unicode.IsDigit(r) || r == '.' || r == ',') {\n\t\t\tbreak\n\t\t}\n\t\tif r == ',' {\n\t\t\thasComma = true\n\t\t}\n\t\tlastDigit++\n\t}\n\n\tnum := s[:lastDigit]\n\tif hasComma {\n\t\tnum = strings.Replace(num, \",\", \"\", -1)\n\t}\n\n\tf, err := strconv.ParseFloat(num, 64)\n\tif err != nil {\n\t\treturn 0, err\n\t}\n\n\textra := strings.ToLower(strings.TrimSpace(s[lastDigit:]))\n\tif m, ok := bytesSizeTable[extra]; ok {\n\t\tf *= float64(m)\n\t\tif f >= math.MaxUint64 {\n\t\t\treturn 0, fmt.Errorf(\"too large: %v\", s)\n\t\t}\n\t\treturn uint64(f), nil\n\t}\n\n\treturn 0, fmt.Errorf(\"unhandled size name: %v\", extra)\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/comma.go",
"content": "package humanize\n\nimport (\n\t\"bytes\"\n\t\"math\"\n\t\"math/big\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// Comma produces a string form of the given number in base 10 with\n// commas after every three orders of magnitude.\n//\n// e.g. Comma(834142) -> 834,142\nfunc Comma(v int64) string {\n\tsign := \"\"\n\n\t// Min int64 can't be negated to a usable value, so it has to be special cased.\n\tif v == math.MinInt64 {\n\t\treturn \"-9,223,372,036,854,775,808\"\n\t}\n\n\tif v < 0 {\n\t\tsign = \"-\"\n\t\tv = 0 - v\n\t}\n\n\tparts := []string{\"\", \"\", \"\", \"\", \"\", \"\", \"\"}\n\tj := len(parts) - 1\n\n\tfor v > 999 {\n\t\tparts[j] = strconv.FormatInt(v%1000, 10)\n\t\tswitch len(parts[j]) {\n\t\tcase 2:\n\t\t\tparts[j] = \"0\" + parts[j]\n\t\tcase 1:\n\t\t\tparts[j] = \"00\" + parts[j]\n\t\t}\n\t\tv = v / 1000\n\t\tj--\n\t}\n\tparts[j] = strconv.Itoa(int(v))\n\treturn sign + strings.Join(parts[j:], \",\")\n}\n\n// Commaf produces a string form of the given number in base 10 with\n// commas after every three orders of magnitude.\n//\n// e.g. Commaf(834142.32) -> 834,142.32\nfunc Commaf(v float64) string {\n\tbuf := &bytes.Buffer{}\n\tif v < 0 {\n\t\tbuf.Write([]byte{'-'})\n\t\tv = 0 - v\n\t}\n\n\tcomma := []byte{','}\n\n\tparts := strings.Split(strconv.FormatFloat(v, 'f', -1, 64), \".\")\n\tpos := 0\n\tif len(parts[0])%3 != 0 {\n\t\tpos += len(parts[0]) % 3\n\t\tbuf.WriteString(parts[0][:pos])\n\t\tbuf.Write(comma)\n\t}\n\tfor ; pos < len(parts[0]); pos += 3 {\n\t\tbuf.WriteString(parts[0][pos : pos+3])\n\t\tbuf.Write(comma)\n\t}\n\tbuf.Truncate(buf.Len() - 1)\n\n\tif len(parts) > 1 {\n\t\tbuf.Write([]byte{'.'})\n\t\tbuf.WriteString(parts[1])\n\t}\n\treturn buf.String()\n}\n\n// CommafWithDigits works like the Commaf but limits the resulting\n// string to the given number of decimal places.\n//\n// e.g. CommafWithDigits(834142.32, 1) -> 834,142.3\nfunc CommafWithDigits(f float64, decimals int) string {\n\treturn stripTrailingDigits(Commaf(f), decimals)\n}\n\n// BigComma produces a string form of the given big.Int in base 10\n// with commas after every three orders of magnitude.\nfunc BigComma(b *big.Int) string {\n\tsign := \"\"\n\tif b.Sign() < 0 {\n\t\tsign = \"-\"\n\t\tb.Abs(b)\n\t}\n\n\tathousand := big.NewInt(1000)\n\tc := (&big.Int{}).Set(b)\n\t_, m := oom(c, athousand)\n\tparts := make([]string, m+1)\n\tj := len(parts) - 1\n\n\tmod := &big.Int{}\n\tfor b.Cmp(athousand) >= 0 {\n\t\tb.DivMod(b, athousand, mod)\n\t\tparts[j] = strconv.FormatInt(mod.Int64(), 10)\n\t\tswitch len(parts[j]) {\n\t\tcase 2:\n\t\t\tparts[j] = \"0\" + parts[j]\n\t\tcase 1:\n\t\t\tparts[j] = \"00\" + parts[j]\n\t\t}\n\t\tj--\n\t}\n\tparts[j] = strconv.Itoa(int(b.Int64()))\n\treturn sign + strings.Join(parts[j:], \",\")\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/commaf.go",
"content": "//go:build go1.6\n// +build go1.6\n\npackage humanize\n\nimport (\n\t\"bytes\"\n\t\"math/big\"\n\t\"strings\"\n)\n\n// BigCommaf produces a string form of the given big.Float in base 10\n// with commas after every three orders of magnitude.\nfunc BigCommaf(v *big.Float) string {\n\tbuf := &bytes.Buffer{}\n\tif v.Sign() < 0 {\n\t\tbuf.Write([]byte{'-'})\n\t\tv.Abs(v)\n\t}\n\n\tcomma := []byte{','}\n\n\tparts := strings.Split(v.Text('f', -1), \".\")\n\tpos := 0\n\tif len(parts[0])%3 != 0 {\n\t\tpos += len(parts[0]) % 3\n\t\tbuf.WriteString(parts[0][:pos])\n\t\tbuf.Write(comma)\n\t}\n\tfor ; pos < len(parts[0]); pos += 3 {\n\t\tbuf.WriteString(parts[0][pos : pos+3])\n\t\tbuf.Write(comma)\n\t}\n\tbuf.Truncate(buf.Len() - 1)\n\n\tif len(parts) > 1 {\n\t\tbuf.Write([]byte{'.'})\n\t\tbuf.WriteString(parts[1])\n\t}\n\treturn buf.String()\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/ftoa.go",
"content": "package humanize\n\nimport (\n\t\"strconv\"\n\t\"strings\"\n)\n\nfunc stripTrailingZeros(s string) string {\n\tif !strings.ContainsRune(s, '.') {\n\t\treturn s\n\t}\n\toffset := len(s) - 1\n\tfor offset > 0 {\n\t\tif s[offset] == '.' {\n\t\t\toffset--\n\t\t\tbreak\n\t\t}\n\t\tif s[offset] != '0' {\n\t\t\tbreak\n\t\t}\n\t\toffset--\n\t}\n\treturn s[:offset+1]\n}\n\nfunc stripTrailingDigits(s string, digits int) string {\n\tif i := strings.Index(s, \".\"); i >= 0 {\n\t\tif digits <= 0 {\n\t\t\treturn s[:i]\n\t\t}\n\t\ti++\n\t\tif i+digits >= len(s) {\n\t\t\treturn s\n\t\t}\n\t\treturn s[:i+digits]\n\t}\n\treturn s\n}\n\n// Ftoa converts a float to a string with no trailing zeros.\nfunc Ftoa(num float64) string {\n\treturn stripTrailingZeros(strconv.FormatFloat(num, 'f', 6, 64))\n}\n\n// FtoaWithDigits converts a float to a string but limits the resulting string\n// to the given number of decimal places, and no trailing zeros.\nfunc FtoaWithDigits(num float64, digits int) string {\n\treturn stripTrailingZeros(stripTrailingDigits(strconv.FormatFloat(num, 'f', 6, 64), digits))\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/humanize.go",
"content": "/*\nPackage humanize converts boring ugly numbers to human-friendly strings and back.\n\nDurations can be turned into strings such as \"3 days ago\", numbers\nrepresenting sizes like 82854982 into useful strings like, \"83 MB\" or\n\"79 MiB\" (whichever you prefer).\n*/\npackage humanize\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/number.go",
"content": "package humanize\n\n/*\nSlightly adapted from the source to fit go-humanize.\n\nAuthor: https://github.com/gorhill\nSource: https://gist.github.com/gorhill/5285193\n\n*/\n\nimport (\n\t\"math\"\n\t\"strconv\"\n)\n\nvar (\n\trenderFloatPrecisionMultipliers = [...]float64{\n\t\t1,\n\t\t10,\n\t\t100,\n\t\t1000,\n\t\t10000,\n\t\t100000,\n\t\t1000000,\n\t\t10000000,\n\t\t100000000,\n\t\t1000000000,\n\t}\n\n\trenderFloatPrecisionRounders = [...]float64{\n\t\t0.5,\n\t\t0.05,\n\t\t0.005,\n\t\t0.0005,\n\t\t0.00005,\n\t\t0.000005,\n\t\t0.0000005,\n\t\t0.00000005,\n\t\t0.000000005,\n\t\t0.0000000005,\n\t}\n)\n\n// FormatFloat produces a formatted number as string based on the following user-specified criteria:\n// * thousands separator\n// * decimal separator\n// * decimal precision\n//\n// Usage: s := RenderFloat(format, n)\n// The format parameter tells how to render the number n.\n//\n// See examples: http://play.golang.org/p/LXc1Ddm1lJ\n//\n// Examples of format strings, given n = 12345.6789:\n// \"#,###.##\" => \"12,345.67\"\n// \"#,###.\" => \"12,345\"\n// \"#,###\" => \"12345,678\"\n// \"#\\u202F###,##\" => \"12 345,68\"\n// \"#.###,###### => 12.345,678900\n// \"\" (aka default format) => 12,345.67\n//\n// The highest precision allowed is 9 digits after the decimal symbol.\n// There is also a version for integer number, FormatInteger(),\n// which is convenient for calls within template.\nfunc FormatFloat(format string, n float64) string {\n\t// Special cases:\n\t// NaN = \"NaN\"\n\t// +Inf = \"+Infinity\"\n\t// -Inf = \"-Infinity\"\n\tif math.IsNaN(n) {\n\t\treturn \"NaN\"\n\t}\n\tif n > math.MaxFloat64 {\n\t\treturn \"Infinity\"\n\t}\n\tif n < (0.0 - math.MaxFloat64) {\n\t\treturn \"-Infinity\"\n\t}\n\n\t// default format\n\tprecision := 2\n\tdecimalStr := \".\"\n\tthousandStr := \",\"\n\tpositiveStr := \"\"\n\tnegativeStr := \"-\"\n\n\tif len(format) > 0 {\n\t\tformat := []rune(format)\n\n\t\t// If there is an explicit format directive,\n\t\t// then default values are these:\n\t\tprecision = 9\n\t\tthousandStr = \"\"\n\n\t\t// collect indices of meaningful formatting directives\n\t\tformatIndx := []int{}\n\t\tfor i, char := range format {\n\t\t\tif char != '#' && char != '0' {\n\t\t\t\tformatIndx = append(formatIndx, i)\n\t\t\t}\n\t\t}\n\n\t\tif len(formatIndx) > 0 {\n\t\t\t// Directive at index 0:\n\t\t\t// Must be a '+'\n\t\t\t// Raise an error if not the case\n\t\t\t// index: 0123456789\n\t\t\t// +0.000,000\n\t\t\t// +000,000.0\n\t\t\t// +0000.00\n\t\t\t// +0000\n\t\t\tif formatIndx[0] == 0 {\n\t\t\t\tif format[formatIndx[0]] != '+' {\n\t\t\t\t\tpanic(\"RenderFloat(): invalid positive sign directive\")\n\t\t\t\t}\n\t\t\t\tpositiveStr = \"+\"\n\t\t\t\tformatIndx = formatIndx[1:]\n\t\t\t}\n\n\t\t\t// Two directives:\n\t\t\t// First is thousands separator\n\t\t\t// Raise an error if not followed by 3-digit\n\t\t\t// 0123456789\n\t\t\t// 0.000,000\n\t\t\t// 000,000.00\n\t\t\tif len(formatIndx) == 2 {\n\t\t\t\tif (formatIndx[1] - formatIndx[0]) != 4 {\n\t\t\t\t\tpanic(\"RenderFloat(): thousands separator directive must be followed by 3 digit-specifiers\")\n\t\t\t\t}\n\t\t\t\tthousandStr = string(format[formatIndx[0]])\n\t\t\t\tformatIndx = formatIndx[1:]\n\t\t\t}\n\n\t\t\t// One directive:\n\t\t\t// Directive is decimal separator\n\t\t\t// The number of digit-specifier following the separator indicates wanted precision\n\t\t\t// 0123456789\n\t\t\t// 0.00\n\t\t\t// 000,0000\n\t\t\tif len(formatIndx) == 1 {\n\t\t\t\tdecimalStr = string(format[formatIndx[0]])\n\t\t\t\tprecision = len(format) - formatIndx[0] - 1\n\t\t\t}\n\t\t}\n\t}\n\n\t// generate sign part\n\tvar signStr string\n\tif n >= 0.000000001 {\n\t\tsignStr = positiveStr\n\t} else if n <= -0.000000001 {\n\t\tsignStr = negativeStr\n\t\tn = -n\n\t} else {\n\t\tsignStr = \"\"\n\t\tn = 0.0\n\t}\n\n\t// split number into integer and fractional parts\n\tintf, fracf := math.Modf(n + renderFloatPrecisionRounders[precision])\n\n\t// generate integer part string\n\tintStr := strconv.FormatInt(int64(intf), 10)\n\n\t// add thousand separator if required\n\tif len(thousandStr) > 0 {\n\t\tfor i := len(intStr); i > 3; {\n\t\t\ti -= 3\n\t\t\tintStr = intStr[:i] + thousandStr + intStr[i:]\n\t\t}\n\t}\n\n\t// no fractional part, we can leave now\n\tif precision == 0 {\n\t\treturn signStr + intStr\n\t}\n\n\t// generate fractional part\n\tfracStr := strconv.Itoa(int(fracf * renderFloatPrecisionMultipliers[precision]))\n\t// may need padding\n\tif len(fracStr) < precision {\n\t\tfracStr = \"000000000000000\"[:precision-len(fracStr)] + fracStr\n\t}\n\n\treturn signStr + intStr + decimalStr + fracStr\n}\n\n// FormatInteger produces a formatted number as string.\n// See FormatFloat.\nfunc FormatInteger(format string, n int) string {\n\treturn FormatFloat(format, float64(n))\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/ordinals.go",
"content": "package humanize\n\nimport \"strconv\"\n\n// Ordinal gives you the input number in a rank/ordinal format.\n//\n// Ordinal(3) -> 3rd\nfunc Ordinal(x int) string {\n\tsuffix := \"th\"\n\tswitch x % 10 {\n\tcase 1:\n\t\tif x%100 != 11 {\n\t\t\tsuffix = \"st\"\n\t\t}\n\tcase 2:\n\t\tif x%100 != 12 {\n\t\t\tsuffix = \"nd\"\n\t\t}\n\tcase 3:\n\t\tif x%100 != 13 {\n\t\t\tsuffix = \"rd\"\n\t\t}\n\t}\n\treturn strconv.Itoa(x) + suffix\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/si.go",
"content": "package humanize\n\nimport (\n\t\"errors\"\n\t\"math\"\n\t\"regexp\"\n\t\"strconv\"\n)\n\nvar siPrefixTable = map[float64]string{\n\t-30: \"q\", // quecto\n\t-27: \"r\", // ronto\n\t-24: \"y\", // yocto\n\t-21: \"z\", // zepto\n\t-18: \"a\", // atto\n\t-15: \"f\", // femto\n\t-12: \"p\", // pico\n\t-9: \"n\", // nano\n\t-6: \"µ\", // micro\n\t-3: \"m\", // milli\n\t0: \"\",\n\t3: \"k\", // kilo\n\t6: \"M\", // mega\n\t9: \"G\", // giga\n\t12: \"T\", // tera\n\t15: \"P\", // peta\n\t18: \"E\", // exa\n\t21: \"Z\", // zetta\n\t24: \"Y\", // yotta\n\t27: \"R\", // ronna\n\t30: \"Q\", // quetta\n}\n\nvar revSIPrefixTable = revfmap(siPrefixTable)\n\n// revfmap reverses the map and precomputes the power multiplier\nfunc revfmap(in map[float64]string) map[string]float64 {\n\trv := map[string]float64{}\n\tfor k, v := range in {\n\t\trv[v] = math.Pow(10, k)\n\t}\n\treturn rv\n}\n\nvar riParseRegex *regexp.Regexp\n\nfunc init() {\n\tri := `^([\\-0-9.]+)\\s?([`\n\tfor _, v := range siPrefixTable {\n\t\tri += v\n\t}\n\tri += `]?)(.*)`\n\n\triParseRegex = regexp.MustCompile(ri)\n}\n\n// ComputeSI finds the most appropriate SI prefix for the given number\n// and returns the prefix along with the value adjusted to be within\n// that prefix.\n//\n// See also: SI, ParseSI.\n//\n// e.g. ComputeSI(2.2345e-12) -> (2.2345, \"p\")\nfunc ComputeSI(input float64) (float64, string) {\n\tif input == 0 {\n\t\treturn 0, \"\"\n\t}\n\tmag := math.Abs(input)\n\texponent := math.Floor(logn(mag, 10))\n\texponent = math.Floor(exponent/3) * 3\n\n\tvalue := mag / math.Pow(10, exponent)\n\n\t// Handle special case where value is exactly 1000.0\n\t// Should return 1 M instead of 1000 k\n\tif value == 1000.0 {\n\t\texponent += 3\n\t\tvalue = mag / math.Pow(10, exponent)\n\t}\n\n\tvalue = math.Copysign(value, input)\n\n\tprefix := siPrefixTable[exponent]\n\treturn value, prefix\n}\n\n// SI returns a string with default formatting.\n//\n// SI uses Ftoa to format float value, removing trailing zeros.\n//\n// See also: ComputeSI, ParseSI.\n//\n// e.g. SI(1000000, \"B\") -> 1 MB\n// e.g. SI(2.2345e-12, \"F\") -> 2.2345 pF\nfunc SI(input float64, unit string) string {\n\tvalue, prefix := ComputeSI(input)\n\treturn Ftoa(value) + \" \" + prefix + unit\n}\n\n// SIWithDigits works like SI but limits the resulting string to the\n// given number of decimal places.\n//\n// e.g. SIWithDigits(1000000, 0, \"B\") -> 1 MB\n// e.g. SIWithDigits(2.2345e-12, 2, \"F\") -> 2.23 pF\nfunc SIWithDigits(input float64, decimals int, unit string) string {\n\tvalue, prefix := ComputeSI(input)\n\treturn FtoaWithDigits(value, decimals) + \" \" + prefix + unit\n}\n\nvar errInvalid = errors.New(\"invalid input\")\n\n// ParseSI parses an SI string back into the number and unit.\n//\n// See also: SI, ComputeSI.\n//\n// e.g. ParseSI(\"2.2345 pF\") -> (2.2345e-12, \"F\", nil)\nfunc ParseSI(input string) (float64, string, error) {\n\tfound := riParseRegex.FindStringSubmatch(input)\n\tif len(found) != 4 {\n\t\treturn 0, \"\", errInvalid\n\t}\n\tmag := revSIPrefixTable[found[2]]\n\tunit := found[3]\n\n\tbase, err := strconv.ParseFloat(found[1], 64)\n\treturn base * mag, unit, err\n}\n"
},
{
"path": "vendor/github.com/dustin/go-humanize/times.go",
"content": "package humanize\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"sort\"\n\t\"time\"\n)\n\n// Seconds-based time units\nconst (\n\tDay = 24 * time.Hour\n\tWeek = 7 * Day\n\tMonth = 30 * Day\n\tYear = 12 * Month\n\tLongTime = 37 * Year\n)\n\n// Time formats a time into a relative string.\n//\n// Time(someT) -> \"3 weeks ago\"\nfunc Time(then time.Time) string {\n\treturn RelTime(then, time.Now(), \"ago\", \"from now\")\n}\n\n// A RelTimeMagnitude struct contains a relative time point at which\n// the relative format of time will switch to a new format string. A\n// slice of these in ascending order by their \"D\" field is passed to\n// CustomRelTime to format durations.\n//\n// The Format field is a string that may contain a \"%s\" which will be\n// replaced with the appropriate signed label (e.g. \"ago\" or \"from\n// now\") and a \"%d\" that will be replaced by the quantity.\n//\n// The DivBy field is the amount of time the time difference must be\n// divided by in order to display correctly.\n//\n// e.g. if D is 2*time.Minute and you want to display \"%d minutes %s\"\n// DivBy should be time.Minute so whatever the duration is will be\n// expressed in minutes.\ntype RelTimeMagnitude struct {\n\tD time.Duration\n\tFormat string\n\tDivBy time.Duration\n}\n\nvar defaultMagnitudes = []RelTimeMagnitude{\n\t{time.Second, \"now\", time.Second},\n\t{2 * time.Second, \"1 second %s\", 1},\n\t{time.Minute, \"%d seconds %s\", time.Second},\n\t{2 * time.Minute, \"1 minute %s\", 1},\n\t{time.Hour, \"%d minutes %s\", time.Minute},\n\t{2 * time.Hour, \"1 hour %s\", 1},\n\t{Day, \"%d hours %s\", time.Hour},\n\t{2 * Day, \"1 day %s\", 1},\n\t{Week, \"%d days %s\", Day},\n\t{2 * Week, \"1 week %s\", 1},\n\t{Month, \"%d weeks %s\", Week},\n\t{2 * Month, \"1 month %s\", 1},\n\t{Year, \"%d months %s\", Month},\n\t{18 * Month, \"1 year %s\", 1},\n\t{2 * Year, \"2 years %s\", 1},\n\t{LongTime, \"%d years %s\", Year},\n\t{math.MaxInt64, \"a long while %s\", 1},\n}\n\n// RelTime formats a time into a relative string.\n//\n// It takes two times and two labels. In addition to the generic time\n// delta string (e.g. 5 minutes), the labels are used applied so that\n// the label corresponding to the smaller time is applied.\n//\n// RelTime(timeInPast, timeInFuture, \"earlier\", \"later\") -> \"3 weeks earlier\"\nfunc RelTime(a, b time.Time, albl, blbl string) string {\n\treturn CustomRelTime(a, b, albl, blbl, defaultMagnitudes)\n}\n\n// CustomRelTime formats a time into a relative string.\n//\n// It takes two times two labels and a table of relative time formats.\n// In addition to the generic time delta string (e.g. 5 minutes), the\n// labels are used applied so that the label corresponding to the\n// smaller time is applied.\nfunc CustomRelTime(a, b time.Time, albl, blbl string, magnitudes []RelTimeMagnitude) string {\n\tlbl := albl\n\tdiff := b.Sub(a)\n\n\tif a.After(b) {\n\t\tlbl = blbl\n\t\tdiff = a.Sub(b)\n\t}\n\n\tn := sort.Search(len(magnitudes), func(i int) bool {\n\t\treturn magnitudes[i].D > diff\n\t})\n\n\tif n >= len(magnitudes) {\n\t\tn = len(magnitudes) - 1\n\t}\n\tmag := magnitudes[n]\n\targs := []interface{}{}\n\tescaped := false\n\tfor _, ch := range mag.Format {\n\t\tif escaped {\n\t\t\tswitch ch {\n\t\t\tcase 's':\n\t\t\t\targs = append(args, lbl)\n\t\t\tcase 'd':\n\t\t\t\targs = append(args, diff/mag.DivBy)\n\t\t\t}\n\t\t\tescaped = false\n\t\t} else {\n\t\t\tescaped = ch == '%'\n\t\t}\n\t}\n\treturn fmt.Sprintf(mag.Format, args...)\n}\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/.cirrus.yml",
"content": "freebsd_task:\n name: 'FreeBSD'\n freebsd_instance:\n image_family: freebsd-13-2\n install_script:\n - pkg update -f\n - pkg install -y go\n test_script:\n # run tests as user \"cirrus\" instead of root\n - pw useradd cirrus -m\n - chown -R cirrus:cirrus .\n - FSNOTIFY_BUFFER=4096 sudo --preserve-env=FSNOTIFY_BUFFER -u cirrus go test -parallel 1 -race ./...\n - sudo --preserve-env=FSNOTIFY_BUFFER -u cirrus go test -parallel 1 -race ./...\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/.editorconfig",
"content": "root = true\n\n[*.go]\nindent_style = tab\nindent_size = 4\ninsert_final_newline = true\n\n[*.{yml,yaml}]\nindent_style = space\nindent_size = 2\ninsert_final_newline = true\ntrim_trailing_whitespace = true\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/.gitattributes",
"content": "go.sum linguist-generated\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/.gitignore",
"content": "# go test -c output\n*.test\n*.test.exe\n\n# Output of go build ./cmd/fsnotify\n/fsnotify\n/fsnotify.exe\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/.mailmap",
"content": "Chris Howey \nNathan Youngman <4566+nathany@users.noreply.github.com>\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/CHANGELOG.md",
"content": "# Changelog\n\nUnreleased\n----------\nNothing yet.\n\n1.7.0 - 2023-10-22\n------------------\nThis version of fsnotify needs Go 1.17.\n\n### Additions\n\n- illumos: add FEN backend to support illumos and Solaris. ([#371])\n\n- all: add `NewBufferedWatcher()` to use a buffered channel, which can be useful\n in cases where you can't control the kernel buffer and receive a large number\n of events in bursts. ([#550], [#572])\n\n- all: add `AddWith()`, which is identical to `Add()` but allows passing\n options. ([#521])\n\n- windows: allow setting the ReadDirectoryChangesW() buffer size with\n `fsnotify.WithBufferSize()`; the default of 64K is the highest value that\n works on all platforms and is enough for most purposes, but in some cases a\n highest buffer is needed. ([#521])\n\n### Changes and fixes\n\n- inotify: remove watcher if a watched path is renamed ([#518])\n\n After a rename the reported name wasn't updated, or even an empty string.\n Inotify doesn't provide any good facilities to update it, so just remove the\n watcher. This is already how it worked on kqueue and FEN.\n\n On Windows this does work, and remains working.\n\n- windows: don't listen for file attribute changes ([#520])\n\n File attribute changes are sent as `FILE_ACTION_MODIFIED` by the Windows API,\n with no way to see if they're a file write or attribute change, so would show\n up as a fsnotify.Write event. This is never useful, and could result in many\n spurious Write events.\n\n- windows: return `ErrEventOverflow` if the buffer is full ([#525])\n\n Before it would merely return \"short read\", making it hard to detect this\n error.\n\n- kqueue: make sure events for all files are delivered properly when removing a\n watched directory ([#526])\n\n Previously they would get sent with `\"\"` (empty string) or `\".\"` as the path\n name.\n\n- kqueue: don't emit spurious Create events for symbolic links ([#524])\n\n The link would get resolved but kqueue would \"forget\" it already saw the link\n itself, resulting on a Create for every Write event for the directory.\n\n- all: return `ErrClosed` on `Add()` when the watcher is closed ([#516])\n\n- other: add `Watcher.Errors` and `Watcher.Events` to the no-op `Watcher` in\n `backend_other.go`, making it easier to use on unsupported platforms such as\n WASM, AIX, etc. ([#528])\n\n- other: use the `backend_other.go` no-op if the `appengine` build tag is set;\n Google AppEngine forbids usage of the unsafe package so the inotify backend\n won't compile there.\n\n[#371]: https://github.com/fsnotify/fsnotify/pull/371\n[#516]: https://github.com/fsnotify/fsnotify/pull/516\n[#518]: https://github.com/fsnotify/fsnotify/pull/518\n[#520]: https://github.com/fsnotify/fsnotify/pull/520\n[#521]: https://github.com/fsnotify/fsnotify/pull/521\n[#524]: https://github.com/fsnotify/fsnotify/pull/524\n[#525]: https://github.com/fsnotify/fsnotify/pull/525\n[#526]: https://github.com/fsnotify/fsnotify/pull/526\n[#528]: https://github.com/fsnotify/fsnotify/pull/528\n[#537]: https://github.com/fsnotify/fsnotify/pull/537\n[#550]: https://github.com/fsnotify/fsnotify/pull/550\n[#572]: https://github.com/fsnotify/fsnotify/pull/572\n\n1.6.0 - 2022-10-13\n------------------\nThis version of fsnotify needs Go 1.16 (this was already the case since 1.5.1,\nbut not documented). It also increases the minimum Linux version to 2.6.32.\n\n### Additions\n\n- all: add `Event.Has()` and `Op.Has()` ([#477])\n\n This makes checking events a lot easier; for example:\n\n\t if event.Op&Write == Write && !(event.Op&Remove == Remove) {\n\t }\n\n\tBecomes:\n\n\t if event.Has(Write) && !event.Has(Remove) {\n\t }\n\n- all: add cmd/fsnotify ([#463])\n\n A command-line utility for testing and some examples.\n\n### Changes and fixes\n\n- inotify: don't ignore events for files that don't exist ([#260], [#470])\n\n Previously the inotify watcher would call `os.Lstat()` to check if a file\n still exists before emitting events.\n\n This was inconsistent with other platforms and resulted in inconsistent event\n reporting (e.g. when a file is quickly removed and re-created), and generally\n a source of confusion. It was added in 2013 to fix a memory leak that no\n longer exists.\n\n- all: return `ErrNonExistentWatch` when `Remove()` is called on a path that's\n not watched ([#460])\n\n- inotify: replace epoll() with non-blocking inotify ([#434])\n\n Non-blocking inotify was not generally available at the time this library was\n written in 2014, but now it is. As a result, the minimum Linux version is\n bumped from 2.6.27 to 2.6.32. This hugely simplifies the code and is faster.\n\n- kqueue: don't check for events every 100ms ([#480])\n\n The watcher would wake up every 100ms, even when there was nothing to do. Now\n it waits until there is something to do.\n\n- macos: retry opening files on EINTR ([#475])\n\n- kqueue: skip unreadable files ([#479])\n\n kqueue requires a file descriptor for every file in a directory; this would\n fail if a file was unreadable by the current user. Now these files are simply\n skipped.\n\n- windows: fix renaming a watched directory if the parent is also watched ([#370])\n\n- windows: increase buffer size from 4K to 64K ([#485])\n\n- windows: close file handle on Remove() ([#288])\n\n- kqueue: put pathname in the error if watching a file fails ([#471])\n\n- inotify, windows: calling Close() more than once could race ([#465])\n\n- kqueue: improve Close() performance ([#233])\n\n- all: various documentation additions and clarifications.\n\n[#233]: https://github.com/fsnotify/fsnotify/pull/233\n[#260]: https://github.com/fsnotify/fsnotify/pull/260\n[#288]: https://github.com/fsnotify/fsnotify/pull/288\n[#370]: https://github.com/fsnotify/fsnotify/pull/370\n[#434]: https://github.com/fsnotify/fsnotify/pull/434\n[#460]: https://github.com/fsnotify/fsnotify/pull/460\n[#463]: https://github.com/fsnotify/fsnotify/pull/463\n[#465]: https://github.com/fsnotify/fsnotify/pull/465\n[#470]: https://github.com/fsnotify/fsnotify/pull/470\n[#471]: https://github.com/fsnotify/fsnotify/pull/471\n[#475]: https://github.com/fsnotify/fsnotify/pull/475\n[#477]: https://github.com/fsnotify/fsnotify/pull/477\n[#479]: https://github.com/fsnotify/fsnotify/pull/479\n[#480]: https://github.com/fsnotify/fsnotify/pull/480\n[#485]: https://github.com/fsnotify/fsnotify/pull/485\n\n## [1.5.4] - 2022-04-25\n\n* Windows: add missing defer to `Watcher.WatchList` [#447](https://github.com/fsnotify/fsnotify/pull/447)\n* go.mod: use latest x/sys [#444](https://github.com/fsnotify/fsnotify/pull/444)\n* Fix compilation for OpenBSD [#443](https://github.com/fsnotify/fsnotify/pull/443)\n\n## [1.5.3] - 2022-04-22\n\n* This version is retracted. An incorrect branch is published accidentally [#445](https://github.com/fsnotify/fsnotify/issues/445)\n\n## [1.5.2] - 2022-04-21\n\n* Add a feature to return the directories and files that are being monitored [#374](https://github.com/fsnotify/fsnotify/pull/374)\n* Fix potential crash on windows if `raw.FileNameLength` exceeds `syscall.MAX_PATH` [#361](https://github.com/fsnotify/fsnotify/pull/361)\n* Allow build on unsupported GOOS [#424](https://github.com/fsnotify/fsnotify/pull/424)\n* Don't set `poller.fd` twice in `newFdPoller` [#406](https://github.com/fsnotify/fsnotify/pull/406)\n* fix go vet warnings: call to `(*T).Fatalf` from a non-test goroutine [#416](https://github.com/fsnotify/fsnotify/pull/416)\n\n## [1.5.1] - 2021-08-24\n\n* Revert Add AddRaw to not follow symlinks [#394](https://github.com/fsnotify/fsnotify/pull/394)\n\n## [1.5.0] - 2021-08-20\n\n* Go: Increase minimum required version to Go 1.12 [#381](https://github.com/fsnotify/fsnotify/pull/381)\n* Feature: Add AddRaw method which does not follow symlinks when adding a watch [#289](https://github.com/fsnotify/fsnotify/pull/298)\n* Windows: Follow symlinks by default like on all other systems [#289](https://github.com/fsnotify/fsnotify/pull/289)\n* CI: Use GitHub Actions for CI and cover go 1.12-1.17\n [#378](https://github.com/fsnotify/fsnotify/pull/378)\n [#381](https://github.com/fsnotify/fsnotify/pull/381)\n [#385](https://github.com/fsnotify/fsnotify/pull/385)\n* Go 1.14+: Fix unsafe pointer conversion [#325](https://github.com/fsnotify/fsnotify/pull/325)\n\n## [1.4.9] - 2020-03-11\n\n* Move example usage to the readme #329. This may resolve #328.\n\n## [1.4.8] - 2020-03-10\n\n* CI: test more go versions (@nathany 1d13583d846ea9d66dcabbfefbfb9d8e6fb05216)\n* Tests: Queued inotify events could have been read by the test before max_queued_events was hit (@matthias-stone #265)\n* Tests: t.Fatalf -> t.Errorf in go routines (@gdey #266)\n* CI: Less verbosity (@nathany #267)\n* Tests: Darwin: Exchangedata is deprecated on 10.13 (@nathany #267)\n* Tests: Check if channels are closed in the example (@alexeykazakov #244)\n* CI: Only run golint on latest version of go and fix issues (@cpuguy83 #284)\n* CI: Add windows to travis matrix (@cpuguy83 #284)\n* Docs: Remover appveyor badge (@nathany 11844c0959f6fff69ba325d097fce35bd85a8e93)\n* Linux: create epoll and pipe fds with close-on-exec (@JohannesEbke #219)\n* Linux: open files with close-on-exec (@linxiulei #273)\n* Docs: Plan to support fanotify (@nathany ab058b44498e8b7566a799372a39d150d9ea0119 )\n* Project: Add go.mod (@nathany #309)\n* Project: Revise editor config (@nathany #309)\n* Project: Update copyright for 2019 (@nathany #309)\n* CI: Drop go1.8 from CI matrix (@nathany #309)\n* Docs: Updating the FAQ section for supportability with NFS & FUSE filesystems (@Pratik32 4bf2d1fec78374803a39307bfb8d340688f4f28e )\n\n## [1.4.7] - 2018-01-09\n\n* BSD/macOS: Fix possible deadlock on closing the watcher on kqueue (thanks @nhooyr and @glycerine)\n* Tests: Fix missing verb on format string (thanks @rchiossi)\n* Linux: Fix deadlock in Remove (thanks @aarondl)\n* Linux: Watch.Add improvements (avoid race, fix consistency, reduce garbage) (thanks @twpayne)\n* Docs: Moved FAQ into the README (thanks @vahe)\n* Linux: Properly handle inotify's IN_Q_OVERFLOW event (thanks @zeldovich)\n* Docs: replace references to OS X with macOS\n\n## [1.4.2] - 2016-10-10\n\n* Linux: use InotifyInit1 with IN_CLOEXEC to stop leaking a file descriptor to a child process when using fork/exec [#178](https://github.com/fsnotify/fsnotify/pull/178) (thanks @pattyshack)\n\n## [1.4.1] - 2016-10-04\n\n* Fix flaky inotify stress test on Linux [#177](https://github.com/fsnotify/fsnotify/pull/177) (thanks @pattyshack)\n\n## [1.4.0] - 2016-10-01\n\n* add a String() method to Event.Op [#165](https://github.com/fsnotify/fsnotify/pull/165) (thanks @oozie)\n\n## [1.3.1] - 2016-06-28\n\n* Windows: fix for double backslash when watching the root of a drive [#151](https://github.com/fsnotify/fsnotify/issues/151) (thanks @brunoqc)\n\n## [1.3.0] - 2016-04-19\n\n* Support linux/arm64 by [patching](https://go-review.googlesource.com/#/c/21971/) x/sys/unix and switching to to it from syscall (thanks @suihkulokki) [#135](https://github.com/fsnotify/fsnotify/pull/135)\n\n## [1.2.10] - 2016-03-02\n\n* Fix golint errors in windows.go [#121](https://github.com/fsnotify/fsnotify/pull/121) (thanks @tiffanyfj)\n\n## [1.2.9] - 2016-01-13\n\nkqueue: Fix logic for CREATE after REMOVE [#111](https://github.com/fsnotify/fsnotify/pull/111) (thanks @bep)\n\n## [1.2.8] - 2015-12-17\n\n* kqueue: fix race condition in Close [#105](https://github.com/fsnotify/fsnotify/pull/105) (thanks @djui for reporting the issue and @ppknap for writing a failing test)\n* inotify: fix race in test\n* enable race detection for continuous integration (Linux, Mac, Windows)\n\n## [1.2.5] - 2015-10-17\n\n* inotify: use epoll_create1 for arm64 support (requires Linux 2.6.27 or later) [#100](https://github.com/fsnotify/fsnotify/pull/100) (thanks @suihkulokki)\n* inotify: fix path leaks [#73](https://github.com/fsnotify/fsnotify/pull/73) (thanks @chamaken)\n* kqueue: watch for rename events on subdirectories [#83](https://github.com/fsnotify/fsnotify/pull/83) (thanks @guotie)\n* kqueue: avoid infinite loops from symlinks cycles [#101](https://github.com/fsnotify/fsnotify/pull/101) (thanks @illicitonion)\n\n## [1.2.1] - 2015-10-14\n\n* kqueue: don't watch named pipes [#98](https://github.com/fsnotify/fsnotify/pull/98) (thanks @evanphx)\n\n## [1.2.0] - 2015-02-08\n\n* inotify: use epoll to wake up readEvents [#66](https://github.com/fsnotify/fsnotify/pull/66) (thanks @PieterD)\n* inotify: closing watcher should now always shut down goroutine [#63](https://github.com/fsnotify/fsnotify/pull/63) (thanks @PieterD)\n* kqueue: close kqueue after removing watches, fixes [#59](https://github.com/fsnotify/fsnotify/issues/59)\n\n## [1.1.1] - 2015-02-05\n\n* inotify: Retry read on EINTR [#61](https://github.com/fsnotify/fsnotify/issues/61) (thanks @PieterD)\n\n## [1.1.0] - 2014-12-12\n\n* kqueue: rework internals [#43](https://github.com/fsnotify/fsnotify/pull/43)\n * add low-level functions\n * only need to store flags on directories\n * less mutexes [#13](https://github.com/fsnotify/fsnotify/issues/13)\n * done can be an unbuffered channel\n * remove calls to os.NewSyscallError\n* More efficient string concatenation for Event.String() [#52](https://github.com/fsnotify/fsnotify/pull/52) (thanks @mdlayher)\n* kqueue: fix regression in rework causing subdirectories to be watched [#48](https://github.com/fsnotify/fsnotify/issues/48)\n* kqueue: cleanup internal watch before sending remove event [#51](https://github.com/fsnotify/fsnotify/issues/51)\n\n## [1.0.4] - 2014-09-07\n\n* kqueue: add dragonfly to the build tags.\n* Rename source code files, rearrange code so exported APIs are at the top.\n* Add done channel to example code. [#37](https://github.com/fsnotify/fsnotify/pull/37) (thanks @chenyukang)\n\n## [1.0.3] - 2014-08-19\n\n* [Fix] Windows MOVED_TO now translates to Create like on BSD and Linux. [#36](https://github.com/fsnotify/fsnotify/issues/36)\n\n## [1.0.2] - 2014-08-17\n\n* [Fix] Missing create events on macOS. [#14](https://github.com/fsnotify/fsnotify/issues/14) (thanks @zhsso)\n* [Fix] Make ./path and path equivalent. (thanks @zhsso)\n\n## [1.0.0] - 2014-08-15\n\n* [API] Remove AddWatch on Windows, use Add.\n* Improve documentation for exported identifiers. [#30](https://github.com/fsnotify/fsnotify/issues/30)\n* Minor updates based on feedback from golint.\n\n## dev / 2014-07-09\n\n* Moved to [github.com/fsnotify/fsnotify](https://github.com/fsnotify/fsnotify).\n* Use os.NewSyscallError instead of returning errno (thanks @hariharan-uno)\n\n## dev / 2014-07-04\n\n* kqueue: fix incorrect mutex used in Close()\n* Update example to demonstrate usage of Op.\n\n## dev / 2014-06-28\n\n* [API] Don't set the Write Op for attribute notifications [#4](https://github.com/fsnotify/fsnotify/issues/4)\n* Fix for String() method on Event (thanks Alex Brainman)\n* Don't build on Plan 9 or Solaris (thanks @4ad)\n\n## dev / 2014-06-21\n\n* Events channel of type Event rather than *Event.\n* [internal] use syscall constants directly for inotify and kqueue.\n* [internal] kqueue: rename events to kevents and fileEvent to event.\n\n## dev / 2014-06-19\n\n* Go 1.3+ required on Windows (uses syscall.ERROR_MORE_DATA internally).\n* [internal] remove cookie from Event struct (unused).\n* [internal] Event struct has the same definition across every OS.\n* [internal] remove internal watch and removeWatch methods.\n\n## dev / 2014-06-12\n\n* [API] Renamed Watch() to Add() and RemoveWatch() to Remove().\n* [API] Pluralized channel names: Events and Errors.\n* [API] Renamed FileEvent struct to Event.\n* [API] Op constants replace methods like IsCreate().\n\n## dev / 2014-06-12\n\n* Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98)\n\n## dev / 2014-05-23\n\n* [API] Remove current implementation of WatchFlags.\n * current implementation doesn't take advantage of OS for efficiency\n * provides little benefit over filtering events as they are received, but has extra bookkeeping and mutexes\n * no tests for the current implementation\n * not fully implemented on Windows [#93](https://github.com/howeyc/fsnotify/issues/93#issuecomment-39285195)\n\n## [0.9.3] - 2014-12-31\n\n* kqueue: cleanup internal watch before sending remove event [#51](https://github.com/fsnotify/fsnotify/issues/51)\n\n## [0.9.2] - 2014-08-17\n\n* [Backport] Fix missing create events on macOS. [#14](https://github.com/fsnotify/fsnotify/issues/14) (thanks @zhsso)\n\n## [0.9.1] - 2014-06-12\n\n* Fix data race on kevent buffer (thanks @tilaks) [#98](https://github.com/howeyc/fsnotify/pull/98)\n\n## [0.9.0] - 2014-01-17\n\n* IsAttrib() for events that only concern a file's metadata [#79][] (thanks @abustany)\n* [Fix] kqueue: fix deadlock [#77][] (thanks @cespare)\n* [NOTICE] Development has moved to `code.google.com/p/go.exp/fsnotify` in preparation for inclusion in the Go standard library.\n\n## [0.8.12] - 2013-11-13\n\n* [API] Remove FD_SET and friends from Linux adapter\n\n## [0.8.11] - 2013-11-02\n\n* [Doc] Add Changelog [#72][] (thanks @nathany)\n* [Doc] Spotlight and double modify events on macOS [#62][] (reported by @paulhammond)\n\n## [0.8.10] - 2013-10-19\n\n* [Fix] kqueue: remove file watches when parent directory is removed [#71][] (reported by @mdwhatcott)\n* [Fix] kqueue: race between Close and readEvents [#70][] (reported by @bernerdschaefer)\n* [Doc] specify OS-specific limits in README (thanks @debrando)\n\n## [0.8.9] - 2013-09-08\n\n* [Doc] Contributing (thanks @nathany)\n* [Doc] update package path in example code [#63][] (thanks @paulhammond)\n* [Doc] GoCI badge in README (Linux only) [#60][]\n* [Doc] Cross-platform testing with Vagrant [#59][] (thanks @nathany)\n\n## [0.8.8] - 2013-06-17\n\n* [Fix] Windows: handle `ERROR_MORE_DATA` on Windows [#49][] (thanks @jbowtie)\n\n## [0.8.7] - 2013-06-03\n\n* [API] Make syscall flags internal\n* [Fix] inotify: ignore event changes\n* [Fix] race in symlink test [#45][] (reported by @srid)\n* [Fix] tests on Windows\n* lower case error messages\n\n## [0.8.6] - 2013-05-23\n\n* kqueue: Use EVT_ONLY flag on Darwin\n* [Doc] Update README with full example\n\n## [0.8.5] - 2013-05-09\n\n* [Fix] inotify: allow monitoring of \"broken\" symlinks (thanks @tsg)\n\n## [0.8.4] - 2013-04-07\n\n* [Fix] kqueue: watch all file events [#40][] (thanks @ChrisBuchholz)\n\n## [0.8.3] - 2013-03-13\n\n* [Fix] inoitfy/kqueue memory leak [#36][] (reported by @nbkolchin)\n* [Fix] kqueue: use fsnFlags for watching a directory [#33][] (reported by @nbkolchin)\n\n## [0.8.2] - 2013-02-07\n\n* [Doc] add Authors\n* [Fix] fix data races for map access [#29][] (thanks @fsouza)\n\n## [0.8.1] - 2013-01-09\n\n* [Fix] Windows path separators\n* [Doc] BSD License\n\n## [0.8.0] - 2012-11-09\n\n* kqueue: directory watching improvements (thanks @vmirage)\n* inotify: add `IN_MOVED_TO` [#25][] (requested by @cpisto)\n* [Fix] kqueue: deleting watched directory [#24][] (reported by @jakerr)\n\n## [0.7.4] - 2012-10-09\n\n* [Fix] inotify: fixes from https://codereview.appspot.com/5418045/ (ugorji)\n* [Fix] kqueue: preserve watch flags when watching for delete [#21][] (reported by @robfig)\n* [Fix] kqueue: watch the directory even if it isn't a new watch (thanks @robfig)\n* [Fix] kqueue: modify after recreation of file\n\n## [0.7.3] - 2012-09-27\n\n* [Fix] kqueue: watch with an existing folder inside the watched folder (thanks @vmirage)\n* [Fix] kqueue: no longer get duplicate CREATE events\n\n## [0.7.2] - 2012-09-01\n\n* kqueue: events for created directories\n\n## [0.7.1] - 2012-07-14\n\n* [Fix] for renaming files\n\n## [0.7.0] - 2012-07-02\n\n* [Feature] FSNotify flags\n* [Fix] inotify: Added file name back to event path\n\n## [0.6.0] - 2012-06-06\n\n* kqueue: watch files after directory created (thanks @tmc)\n\n## [0.5.1] - 2012-05-22\n\n* [Fix] inotify: remove all watches before Close()\n\n## [0.5.0] - 2012-05-03\n\n* [API] kqueue: return errors during watch instead of sending over channel\n* kqueue: match symlink behavior on Linux\n* inotify: add `DELETE_SELF` (requested by @taralx)\n* [Fix] kqueue: handle EINTR (reported by @robfig)\n* [Doc] Godoc example [#1][] (thanks @davecheney)\n\n## [0.4.0] - 2012-03-30\n\n* Go 1 released: build with go tool\n* [Feature] Windows support using winfsnotify\n* Windows does not have attribute change notifications\n* Roll attribute notifications into IsModify\n\n## [0.3.0] - 2012-02-19\n\n* kqueue: add files when watch directory\n\n## [0.2.0] - 2011-12-30\n\n* update to latest Go weekly code\n\n## [0.1.0] - 2011-10-19\n\n* kqueue: add watch on file creation to match inotify\n* kqueue: create file event\n* inotify: ignore `IN_IGNORED` events\n* event String()\n* linux: common FileEvent functions\n* initial commit\n\n[#79]: https://github.com/howeyc/fsnotify/pull/79\n[#77]: https://github.com/howeyc/fsnotify/pull/77\n[#72]: https://github.com/howeyc/fsnotify/issues/72\n[#71]: https://github.com/howeyc/fsnotify/issues/71\n[#70]: https://github.com/howeyc/fsnotify/issues/70\n[#63]: https://github.com/howeyc/fsnotify/issues/63\n[#62]: https://github.com/howeyc/fsnotify/issues/62\n[#60]: https://github.com/howeyc/fsnotify/issues/60\n[#59]: https://github.com/howeyc/fsnotify/issues/59\n[#49]: https://github.com/howeyc/fsnotify/issues/49\n[#45]: https://github.com/howeyc/fsnotify/issues/45\n[#40]: https://github.com/howeyc/fsnotify/issues/40\n[#36]: https://github.com/howeyc/fsnotify/issues/36\n[#33]: https://github.com/howeyc/fsnotify/issues/33\n[#29]: https://github.com/howeyc/fsnotify/issues/29\n[#25]: https://github.com/howeyc/fsnotify/issues/25\n[#24]: https://github.com/howeyc/fsnotify/issues/24\n[#21]: https://github.com/howeyc/fsnotify/issues/21\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/CONTRIBUTING.md",
"content": "Thank you for your interest in contributing to fsnotify! We try to review and\nmerge PRs in a reasonable timeframe, but please be aware that:\n\n- To avoid \"wasted\" work, please discus changes on the issue tracker first. You\n can just send PRs, but they may end up being rejected for one reason or the\n other.\n\n- fsnotify is a cross-platform library, and changes must work reasonably well on\n all supported platforms.\n\n- Changes will need to be compatible; old code should still compile, and the\n runtime behaviour can't change in ways that are likely to lead to problems for\n users.\n\nTesting\n-------\nJust `go test ./...` runs all the tests; the CI runs this on all supported\nplatforms. Testing different platforms locally can be done with something like\n[goon] or [Vagrant], but this isn't super-easy to set up at the moment.\n\nUse the `-short` flag to make the \"stress test\" run faster.\n\n\n[goon]: https://github.com/arp242/goon\n[Vagrant]: https://www.vagrantup.com/\n[integration_test.go]: /integration_test.go\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/LICENSE",
"content": "Copyright © 2012 The Go Authors. All rights reserved.\nCopyright © fsnotify Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification,\nare permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n* Redistributions in binary form must reproduce the above copyright notice, this\n list of conditions and the following disclaimer in the documentation and/or\n other materials provided with the distribution.\n* Neither the name of Google Inc. nor the names of its contributors may be used\n to endorse or promote products derived from this software without specific\n prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR\nANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\nLOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\nANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/README.md",
"content": "fsnotify is a Go library to provide cross-platform filesystem notifications on\nWindows, Linux, macOS, BSD, and illumos.\n\nGo 1.17 or newer is required; the full documentation is at\nhttps://pkg.go.dev/github.com/fsnotify/fsnotify\n\n---\n\nPlatform support:\n\n| Backend | OS | Status |\n| :-------------------- | :--------- | :------------------------------------------------------------------------ |\n| inotify | Linux | Supported |\n| kqueue | BSD, macOS | Supported |\n| ReadDirectoryChangesW | Windows | Supported |\n| FEN | illumos | Supported |\n| fanotify | Linux 5.9+ | [Not yet](https://github.com/fsnotify/fsnotify/issues/114) |\n| AHAFS | AIX | [aix branch]; experimental due to lack of maintainer and test environment |\n| FSEvents | macOS | [Needs support in x/sys/unix][fsevents] |\n| USN Journals | Windows | [Needs support in x/sys/windows][usn] |\n| Polling | *All* | [Not yet](https://github.com/fsnotify/fsnotify/issues/9) |\n\nLinux and illumos should include Android and Solaris, but these are currently\nuntested.\n\n[fsevents]: https://github.com/fsnotify/fsnotify/issues/11#issuecomment-1279133120\n[usn]: https://github.com/fsnotify/fsnotify/issues/53#issuecomment-1279829847\n[aix branch]: https://github.com/fsnotify/fsnotify/issues/353#issuecomment-1284590129\n\nUsage\n-----\nA basic example:\n\n```go\npackage main\n\nimport (\n \"log\"\n\n \"github.com/fsnotify/fsnotify\"\n)\n\nfunc main() {\n // Create new watcher.\n watcher, err := fsnotify.NewWatcher()\n if err != nil {\n log.Fatal(err)\n }\n defer watcher.Close()\n\n // Start listening for events.\n go func() {\n for {\n select {\n case event, ok := <-watcher.Events:\n if !ok {\n return\n }\n log.Println(\"event:\", event)\n if event.Has(fsnotify.Write) {\n log.Println(\"modified file:\", event.Name)\n }\n case err, ok := <-watcher.Errors:\n if !ok {\n return\n }\n log.Println(\"error:\", err)\n }\n }\n }()\n\n // Add a path.\n err = watcher.Add(\"/tmp\")\n if err != nil {\n log.Fatal(err)\n }\n\n // Block main goroutine forever.\n <-make(chan struct{})\n}\n```\n\nSome more examples can be found in [cmd/fsnotify](cmd/fsnotify), which can be\nrun with:\n\n % go run ./cmd/fsnotify\n\nFurther detailed documentation can be found in godoc:\nhttps://pkg.go.dev/github.com/fsnotify/fsnotify\n\nFAQ\n---\n### Will a file still be watched when it's moved to another directory?\nNo, not unless you are watching the location it was moved to.\n\n### Are subdirectories watched?\nNo, you must add watches for any directory you want to watch (a recursive\nwatcher is on the roadmap: [#18]).\n\n[#18]: https://github.com/fsnotify/fsnotify/issues/18\n\n### Do I have to watch the Error and Event channels in a goroutine?\nYes. You can read both channels in the same goroutine using `select` (you don't\nneed a separate goroutine for both channels; see the example).\n\n### Why don't notifications work with NFS, SMB, FUSE, /proc, or /sys?\nfsnotify requires support from underlying OS to work. The current NFS and SMB\nprotocols does not provide network level support for file notifications, and\nneither do the /proc and /sys virtual filesystems.\n\nThis could be fixed with a polling watcher ([#9]), but it's not yet implemented.\n\n[#9]: https://github.com/fsnotify/fsnotify/issues/9\n\n### Why do I get many Chmod events?\nSome programs may generate a lot of attribute changes; for example Spotlight on\nmacOS, anti-virus programs, backup applications, and some others are known to do\nthis. As a rule, it's typically best to ignore Chmod events. They're often not\nuseful, and tend to cause problems.\n\nSpotlight indexing on macOS can result in multiple events (see [#15]). A\ntemporary workaround is to add your folder(s) to the *Spotlight Privacy\nsettings* until we have a native FSEvents implementation (see [#11]).\n\n[#11]: https://github.com/fsnotify/fsnotify/issues/11\n[#15]: https://github.com/fsnotify/fsnotify/issues/15\n\n### Watching a file doesn't work well\nWatching individual files (rather than directories) is generally not recommended\nas many programs (especially editors) update files atomically: it will write to\na temporary file which is then moved to to destination, overwriting the original\n(or some variant thereof). The watcher on the original file is now lost, as that\nno longer exists.\n\nThe upshot of this is that a power failure or crash won't leave a half-written\nfile.\n\nWatch the parent directory and use `Event.Name` to filter out files you're not\ninterested in. There is an example of this in `cmd/fsnotify/file.go`.\n\nPlatform-specific notes\n-----------------------\n### Linux\nWhen a file is removed a REMOVE event won't be emitted until all file\ndescriptors are closed; it will emit a CHMOD instead:\n\n fp := os.Open(\"file\")\n os.Remove(\"file\") // CHMOD\n fp.Close() // REMOVE\n\nThis is the event that inotify sends, so not much can be changed about this.\n\nThe `fs.inotify.max_user_watches` sysctl variable specifies the upper limit for\nthe number of watches per user, and `fs.inotify.max_user_instances` specifies\nthe maximum number of inotify instances per user. Every Watcher you create is an\n\"instance\", and every path you add is a \"watch\".\n\nThese are also exposed in `/proc` as `/proc/sys/fs/inotify/max_user_watches` and\n`/proc/sys/fs/inotify/max_user_instances`\n\nTo increase them you can use `sysctl` or write the value to proc file:\n\n # The default values on Linux 5.18\n sysctl fs.inotify.max_user_watches=124983\n sysctl fs.inotify.max_user_instances=128\n\nTo make the changes persist on reboot edit `/etc/sysctl.conf` or\n`/usr/lib/sysctl.d/50-default.conf` (details differ per Linux distro; check your\ndistro's documentation):\n\n fs.inotify.max_user_watches=124983\n fs.inotify.max_user_instances=128\n\nReaching the limit will result in a \"no space left on device\" or \"too many open\nfiles\" error.\n\n### kqueue (macOS, all BSD systems)\nkqueue requires opening a file descriptor for every file that's being watched;\nso if you're watching a directory with five files then that's six file\ndescriptors. You will run in to your system's \"max open files\" limit faster on\nthese platforms.\n\nThe sysctl variables `kern.maxfiles` and `kern.maxfilesperproc` can be used to\ncontrol the maximum number of open files.\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/backend_fen.go",
"content": "//go:build solaris\n// +build solaris\n\n// Note: the documentation on the Watcher type and methods is generated from\n// mkdoc.zsh\n\npackage fsnotify\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"sync\"\n\n\t\"golang.org/x/sys/unix\"\n)\n\n// Watcher watches a set of paths, delivering events on a channel.\n//\n// A watcher should not be copied (e.g. pass it by pointer, rather than by\n// value).\n//\n// # Linux notes\n//\n// When a file is removed a Remove event won't be emitted until all file\n// descriptors are closed, and deletes will always emit a Chmod. For example:\n//\n//\tfp := os.Open(\"file\")\n//\tos.Remove(\"file\") // Triggers Chmod\n//\tfp.Close() // Triggers Remove\n//\n// This is the event that inotify sends, so not much can be changed about this.\n//\n// The fs.inotify.max_user_watches sysctl variable specifies the upper limit\n// for the number of watches per user, and fs.inotify.max_user_instances\n// specifies the maximum number of inotify instances per user. Every Watcher you\n// create is an \"instance\", and every path you add is a \"watch\".\n//\n// These are also exposed in /proc as /proc/sys/fs/inotify/max_user_watches and\n// /proc/sys/fs/inotify/max_user_instances\n//\n// To increase them you can use sysctl or write the value to the /proc file:\n//\n//\t# Default values on Linux 5.18\n//\tsysctl fs.inotify.max_user_watches=124983\n//\tsysctl fs.inotify.max_user_instances=128\n//\n// To make the changes persist on reboot edit /etc/sysctl.conf or\n// /usr/lib/sysctl.d/50-default.conf (details differ per Linux distro; check\n// your distro's documentation):\n//\n//\tfs.inotify.max_user_watches=124983\n//\tfs.inotify.max_user_instances=128\n//\n// Reaching the limit will result in a \"no space left on device\" or \"too many open\n// files\" error.\n//\n// # kqueue notes (macOS, BSD)\n//\n// kqueue requires opening a file descriptor for every file that's being watched;\n// so if you're watching a directory with five files then that's six file\n// descriptors. You will run in to your system's \"max open files\" limit faster on\n// these platforms.\n//\n// The sysctl variables kern.maxfiles and kern.maxfilesperproc can be used to\n// control the maximum number of open files, as well as /etc/login.conf on BSD\n// systems.\n//\n// # Windows notes\n//\n// Paths can be added as \"C:\\path\\to\\dir\", but forward slashes\n// (\"C:/path/to/dir\") will also work.\n//\n// When a watched directory is removed it will always send an event for the\n// directory itself, but may not send events for all files in that directory.\n// Sometimes it will send events for all times, sometimes it will send no\n// events, and often only for some files.\n//\n// The default ReadDirectoryChangesW() buffer size is 64K, which is the largest\n// value that is guaranteed to work with SMB filesystems. If you have many\n// events in quick succession this may not be enough, and you will have to use\n// [WithBufferSize] to increase the value.\ntype Watcher struct {\n\t// Events sends the filesystem change events.\n\t//\n\t// fsnotify can send the following events; a \"path\" here can refer to a\n\t// file, directory, symbolic link, or special file like a FIFO.\n\t//\n\t// fsnotify.Create A new path was created; this may be followed by one\n\t// or more Write events if data also gets written to a\n\t// file.\n\t//\n\t// fsnotify.Remove A path was removed.\n\t//\n\t// fsnotify.Rename A path was renamed. A rename is always sent with the\n\t// old path as Event.Name, and a Create event will be\n\t// sent with the new name. Renames are only sent for\n\t// paths that are currently watched; e.g. moving an\n\t// unmonitored file into a monitored directory will\n\t// show up as just a Create. Similarly, renaming a file\n\t// to outside a monitored directory will show up as\n\t// only a Rename.\n\t//\n\t// fsnotify.Write A file or named pipe was written to. A Truncate will\n\t// also trigger a Write. A single \"write action\"\n\t// initiated by the user may show up as one or multiple\n\t// writes, depending on when the system syncs things to\n\t// disk. For example when compiling a large Go program\n\t// you may get hundreds of Write events, and you may\n\t// want to wait until you've stopped receiving them\n\t// (see the dedup example in cmd/fsnotify).\n\t//\n\t// Some systems may send Write event for directories\n\t// when the directory content changes.\n\t//\n\t// fsnotify.Chmod Attributes were changed. On Linux this is also sent\n\t// when a file is removed (or more accurately, when a\n\t// link to an inode is removed). On kqueue it's sent\n\t// when a file is truncated. On Windows it's never\n\t// sent.\n\tEvents chan Event\n\n\t// Errors sends any errors.\n\t//\n\t// ErrEventOverflow is used to indicate there are too many events:\n\t//\n\t// - inotify: There are too many queued events (fs.inotify.max_queued_events sysctl)\n\t// - windows: The buffer size is too small; WithBufferSize() can be used to increase it.\n\t// - kqueue, fen: Not used.\n\tErrors chan error\n\n\tmu sync.Mutex\n\tport *unix.EventPort\n\tdone chan struct{} // Channel for sending a \"quit message\" to the reader goroutine\n\tdirs map[string]struct{} // Explicitly watched directories\n\twatches map[string]struct{} // Explicitly watched non-directories\n}\n\n// NewWatcher creates a new Watcher.\nfunc NewWatcher() (*Watcher, error) {\n\treturn NewBufferedWatcher(0)\n}\n\n// NewBufferedWatcher creates a new Watcher with a buffered Watcher.Events\n// channel.\n//\n// The main use case for this is situations with a very large number of events\n// where the kernel buffer size can't be increased (e.g. due to lack of\n// permissions). An unbuffered Watcher will perform better for almost all use\n// cases, and whenever possible you will be better off increasing the kernel\n// buffers instead of adding a large userspace buffer.\nfunc NewBufferedWatcher(sz uint) (*Watcher, error) {\n\tw := &Watcher{\n\t\tEvents: make(chan Event, sz),\n\t\tErrors: make(chan error),\n\t\tdirs: make(map[string]struct{}),\n\t\twatches: make(map[string]struct{}),\n\t\tdone: make(chan struct{}),\n\t}\n\n\tvar err error\n\tw.port, err = unix.NewEventPort()\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"fsnotify.NewWatcher: %w\", err)\n\t}\n\n\tgo w.readEvents()\n\treturn w, nil\n}\n\n// sendEvent attempts to send an event to the user, returning true if the event\n// was put in the channel successfully and false if the watcher has been closed.\nfunc (w *Watcher) sendEvent(name string, op Op) (sent bool) {\n\tselect {\n\tcase w.Events <- Event{Name: name, Op: op}:\n\t\treturn true\n\tcase <-w.done:\n\t\treturn false\n\t}\n}\n\n// sendError attempts to send an error to the user, returning true if the error\n// was put in the channel successfully and false if the watcher has been closed.\nfunc (w *Watcher) sendError(err error) (sent bool) {\n\tselect {\n\tcase w.Errors <- err:\n\t\treturn true\n\tcase <-w.done:\n\t\treturn false\n\t}\n}\n\nfunc (w *Watcher) isClosed() bool {\n\tselect {\n\tcase <-w.done:\n\t\treturn true\n\tdefault:\n\t\treturn false\n\t}\n}\n\n// Close removes all watches and closes the Events channel.\nfunc (w *Watcher) Close() error {\n\t// Take the lock used by associateFile to prevent lingering events from\n\t// being processed after the close\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\tif w.isClosed() {\n\t\treturn nil\n\t}\n\tclose(w.done)\n\treturn w.port.Close()\n}\n\n// Add starts monitoring the path for changes.\n//\n// A path can only be watched once; watching it more than once is a no-op and will\n// not return an error. Paths that do not yet exist on the filesystem cannot be\n// watched.\n//\n// A watch will be automatically removed if the watched path is deleted or\n// renamed. The exception is the Windows backend, which doesn't remove the\n// watcher on renames.\n//\n// Notifications on network filesystems (NFS, SMB, FUSE, etc.) or special\n// filesystems (/proc, /sys, etc.) generally don't work.\n//\n// Returns [ErrClosed] if [Watcher.Close] was called.\n//\n// See [Watcher.AddWith] for a version that allows adding options.\n//\n// # Watching directories\n//\n// All files in a directory are monitored, including new files that are created\n// after the watcher is started. Subdirectories are not watched (i.e. it's\n// non-recursive).\n//\n// # Watching files\n//\n// Watching individual files (rather than directories) is generally not\n// recommended as many programs (especially editors) update files atomically: it\n// will write to a temporary file which is then moved to to destination,\n// overwriting the original (or some variant thereof). The watcher on the\n// original file is now lost, as that no longer exists.\n//\n// The upshot of this is that a power failure or crash won't leave a\n// half-written file.\n//\n// Watch the parent directory and use Event.Name to filter out files you're not\n// interested in. There is an example of this in cmd/fsnotify/file.go.\nfunc (w *Watcher) Add(name string) error { return w.AddWith(name) }\n\n// AddWith is like [Watcher.Add], but allows adding options. When using Add()\n// the defaults described below are used.\n//\n// Possible options are:\n//\n// - [WithBufferSize] sets the buffer size for the Windows backend; no-op on\n// other platforms. The default is 64K (65536 bytes).\nfunc (w *Watcher) AddWith(name string, opts ...addOpt) error {\n\tif w.isClosed() {\n\t\treturn ErrClosed\n\t}\n\tif w.port.PathIsWatched(name) {\n\t\treturn nil\n\t}\n\n\t_ = getOptions(opts...)\n\n\t// Currently we resolve symlinks that were explicitly requested to be\n\t// watched. Otherwise we would use LStat here.\n\tstat, err := os.Stat(name)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t// Associate all files in the directory.\n\tif stat.IsDir() {\n\t\terr := w.handleDirectory(name, stat, true, w.associateFile)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\n\t\tw.mu.Lock()\n\t\tw.dirs[name] = struct{}{}\n\t\tw.mu.Unlock()\n\t\treturn nil\n\t}\n\n\terr = w.associateFile(name, stat, true)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tw.mu.Lock()\n\tw.watches[name] = struct{}{}\n\tw.mu.Unlock()\n\treturn nil\n}\n\n// Remove stops monitoring the path for changes.\n//\n// Directories are always removed non-recursively. For example, if you added\n// /tmp/dir and /tmp/dir/subdir then you will need to remove both.\n//\n// Removing a path that has not yet been added returns [ErrNonExistentWatch].\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) Remove(name string) error {\n\tif w.isClosed() {\n\t\treturn nil\n\t}\n\tif !w.port.PathIsWatched(name) {\n\t\treturn fmt.Errorf(\"%w: %s\", ErrNonExistentWatch, name)\n\t}\n\n\t// The user has expressed an intent. Immediately remove this name from\n\t// whichever watch list it might be in. If it's not in there the delete\n\t// doesn't cause harm.\n\tw.mu.Lock()\n\tdelete(w.watches, name)\n\tdelete(w.dirs, name)\n\tw.mu.Unlock()\n\n\tstat, err := os.Stat(name)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t// Remove associations for every file in the directory.\n\tif stat.IsDir() {\n\t\terr := w.handleDirectory(name, stat, false, w.dissociateFile)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\treturn nil\n\t}\n\n\terr = w.port.DissociatePath(name)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\treturn nil\n}\n\n// readEvents contains the main loop that runs in a goroutine watching for events.\nfunc (w *Watcher) readEvents() {\n\t// If this function returns, the watcher has been closed and we can close\n\t// these channels\n\tdefer func() {\n\t\tclose(w.Errors)\n\t\tclose(w.Events)\n\t}()\n\n\tpevents := make([]unix.PortEvent, 8)\n\tfor {\n\t\tcount, err := w.port.Get(pevents, 1, nil)\n\t\tif err != nil && err != unix.ETIME {\n\t\t\t// Interrupted system call (count should be 0) ignore and continue\n\t\t\tif errors.Is(err, unix.EINTR) && count == 0 {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\t// Get failed because we called w.Close()\n\t\t\tif errors.Is(err, unix.EBADF) && w.isClosed() {\n\t\t\t\treturn\n\t\t\t}\n\t\t\t// There was an error not caused by calling w.Close()\n\t\t\tif !w.sendError(err) {\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\n\t\tp := pevents[:count]\n\t\tfor _, pevent := range p {\n\t\t\tif pevent.Source != unix.PORT_SOURCE_FILE {\n\t\t\t\t// Event from unexpected source received; should never happen.\n\t\t\t\tif !w.sendError(errors.New(\"Event from unexpected source received\")) {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\terr = w.handleEvent(&pevent)\n\t\t\tif err != nil {\n\t\t\t\tif !w.sendError(err) {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunc (w *Watcher) handleDirectory(path string, stat os.FileInfo, follow bool, handler func(string, os.FileInfo, bool) error) error {\n\tfiles, err := os.ReadDir(path)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t// Handle all children of the directory.\n\tfor _, entry := range files {\n\t\tfinfo, err := entry.Info()\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\terr = handler(filepath.Join(path, finfo.Name()), finfo, false)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\n\t// And finally handle the directory itself.\n\treturn handler(path, stat, follow)\n}\n\n// handleEvent might need to emit more than one fsnotify event if the events\n// bitmap matches more than one event type (e.g. the file was both modified and\n// had the attributes changed between when the association was created and the\n// when event was returned)\nfunc (w *Watcher) handleEvent(event *unix.PortEvent) error {\n\tvar (\n\t\tevents = event.Events\n\t\tpath = event.Path\n\t\tfmode = event.Cookie.(os.FileMode)\n\t\treRegister = true\n\t)\n\n\tw.mu.Lock()\n\t_, watchedDir := w.dirs[path]\n\t_, watchedPath := w.watches[path]\n\tw.mu.Unlock()\n\tisWatched := watchedDir || watchedPath\n\n\tif events&unix.FILE_DELETE != 0 {\n\t\tif !w.sendEvent(path, Remove) {\n\t\t\treturn nil\n\t\t}\n\t\treRegister = false\n\t}\n\tif events&unix.FILE_RENAME_FROM != 0 {\n\t\tif !w.sendEvent(path, Rename) {\n\t\t\treturn nil\n\t\t}\n\t\t// Don't keep watching the new file name\n\t\treRegister = false\n\t}\n\tif events&unix.FILE_RENAME_TO != 0 {\n\t\t// We don't report a Rename event for this case, because Rename events\n\t\t// are interpreted as referring to the _old_ name of the file, and in\n\t\t// this case the event would refer to the new name of the file. This\n\t\t// type of rename event is not supported by fsnotify.\n\n\t\t// inotify reports a Remove event in this case, so we simulate this\n\t\t// here.\n\t\tif !w.sendEvent(path, Remove) {\n\t\t\treturn nil\n\t\t}\n\t\t// Don't keep watching the file that was removed\n\t\treRegister = false\n\t}\n\n\t// The file is gone, nothing left to do.\n\tif !reRegister {\n\t\tif watchedDir {\n\t\t\tw.mu.Lock()\n\t\t\tdelete(w.dirs, path)\n\t\t\tw.mu.Unlock()\n\t\t}\n\t\tif watchedPath {\n\t\t\tw.mu.Lock()\n\t\t\tdelete(w.watches, path)\n\t\t\tw.mu.Unlock()\n\t\t}\n\t\treturn nil\n\t}\n\n\t// If we didn't get a deletion the file still exists and we're going to have\n\t// to watch it again. Let's Stat it now so that we can compare permissions\n\t// and have what we need to continue watching the file\n\n\tstat, err := os.Lstat(path)\n\tif err != nil {\n\t\t// This is unexpected, but we should still emit an event. This happens\n\t\t// most often on \"rm -r\" of a subdirectory inside a watched directory We\n\t\t// get a modify event of something happening inside, but by the time we\n\t\t// get here, the sudirectory is already gone. Clearly we were watching\n\t\t// this path but now it is gone. Let's tell the user that it was\n\t\t// removed.\n\t\tif !w.sendEvent(path, Remove) {\n\t\t\treturn nil\n\t\t}\n\t\t// Suppress extra write events on removed directories; they are not\n\t\t// informative and can be confusing.\n\t\treturn nil\n\t}\n\n\t// resolve symlinks that were explicitly watched as we would have at Add()\n\t// time. this helps suppress spurious Chmod events on watched symlinks\n\tif isWatched {\n\t\tstat, err = os.Stat(path)\n\t\tif err != nil {\n\t\t\t// The symlink still exists, but the target is gone. Report the\n\t\t\t// Remove similar to above.\n\t\t\tif !w.sendEvent(path, Remove) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t\t// Don't return the error\n\t\t}\n\t}\n\n\tif events&unix.FILE_MODIFIED != 0 {\n\t\tif fmode.IsDir() {\n\t\t\tif watchedDir {\n\t\t\t\tif err := w.updateDirectory(path); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif !w.sendEvent(path, Write) {\n\t\t\t\t\treturn nil\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif !w.sendEvent(path, Write) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t}\n\t}\n\tif events&unix.FILE_ATTRIB != 0 && stat != nil {\n\t\t// Only send Chmod if perms changed\n\t\tif stat.Mode().Perm() != fmode.Perm() {\n\t\t\tif !w.sendEvent(path, Chmod) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t}\n\t}\n\n\tif stat != nil {\n\t\t// If we get here, it means we've hit an event above that requires us to\n\t\t// continue watching the file or directory\n\t\treturn w.associateFile(path, stat, isWatched)\n\t}\n\treturn nil\n}\n\nfunc (w *Watcher) updateDirectory(path string) error {\n\t// The directory was modified, so we must find unwatched entities and watch\n\t// them. If something was removed from the directory, nothing will happen,\n\t// as everything else should still be watched.\n\tfiles, err := os.ReadDir(path)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tfor _, entry := range files {\n\t\tpath := filepath.Join(path, entry.Name())\n\t\tif w.port.PathIsWatched(path) {\n\t\t\tcontinue\n\t\t}\n\n\t\tfinfo, err := entry.Info()\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\terr = w.associateFile(path, finfo, false)\n\t\tif err != nil {\n\t\t\tif !w.sendError(err) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t}\n\t\tif !w.sendEvent(path, Create) {\n\t\t\treturn nil\n\t\t}\n\t}\n\treturn nil\n}\n\nfunc (w *Watcher) associateFile(path string, stat os.FileInfo, follow bool) error {\n\tif w.isClosed() {\n\t\treturn ErrClosed\n\t}\n\t// This is primarily protecting the call to AssociatePath but it is\n\t// important and intentional that the call to PathIsWatched is also\n\t// protected by this mutex. Without this mutex, AssociatePath has been seen\n\t// to error out that the path is already associated.\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\n\tif w.port.PathIsWatched(path) {\n\t\t// Remove the old association in favor of this one If we get ENOENT,\n\t\t// then while the x/sys/unix wrapper still thought that this path was\n\t\t// associated, the underlying event port did not. This call will have\n\t\t// cleared up that discrepancy. The most likely cause is that the event\n\t\t// has fired but we haven't processed it yet.\n\t\terr := w.port.DissociatePath(path)\n\t\tif err != nil && err != unix.ENOENT {\n\t\t\treturn err\n\t\t}\n\t}\n\t// FILE_NOFOLLOW means we watch symlinks themselves rather than their\n\t// targets.\n\tevents := unix.FILE_MODIFIED | unix.FILE_ATTRIB | unix.FILE_NOFOLLOW\n\tif follow {\n\t\t// We *DO* follow symlinks for explicitly watched entries.\n\t\tevents = unix.FILE_MODIFIED | unix.FILE_ATTRIB\n\t}\n\treturn w.port.AssociatePath(path, stat,\n\t\tevents,\n\t\tstat.Mode())\n}\n\nfunc (w *Watcher) dissociateFile(path string, stat os.FileInfo, unused bool) error {\n\tif !w.port.PathIsWatched(path) {\n\t\treturn nil\n\t}\n\treturn w.port.DissociatePath(path)\n}\n\n// WatchList returns all paths explicitly added with [Watcher.Add] (and are not\n// yet removed).\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) WatchList() []string {\n\tif w.isClosed() {\n\t\treturn nil\n\t}\n\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\n\tentries := make([]string, 0, len(w.watches)+len(w.dirs))\n\tfor pathname := range w.dirs {\n\t\tentries = append(entries, pathname)\n\t}\n\tfor pathname := range w.watches {\n\t\tentries = append(entries, pathname)\n\t}\n\n\treturn entries\n}\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/backend_inotify.go",
"content": "//go:build linux && !appengine\n// +build linux,!appengine\n\n// Note: the documentation on the Watcher type and methods is generated from\n// mkdoc.zsh\n\npackage fsnotify\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"sync\"\n\t\"unsafe\"\n\n\t\"golang.org/x/sys/unix\"\n)\n\n// Watcher watches a set of paths, delivering events on a channel.\n//\n// A watcher should not be copied (e.g. pass it by pointer, rather than by\n// value).\n//\n// # Linux notes\n//\n// When a file is removed a Remove event won't be emitted until all file\n// descriptors are closed, and deletes will always emit a Chmod. For example:\n//\n//\tfp := os.Open(\"file\")\n//\tos.Remove(\"file\") // Triggers Chmod\n//\tfp.Close() // Triggers Remove\n//\n// This is the event that inotify sends, so not much can be changed about this.\n//\n// The fs.inotify.max_user_watches sysctl variable specifies the upper limit\n// for the number of watches per user, and fs.inotify.max_user_instances\n// specifies the maximum number of inotify instances per user. Every Watcher you\n// create is an \"instance\", and every path you add is a \"watch\".\n//\n// These are also exposed in /proc as /proc/sys/fs/inotify/max_user_watches and\n// /proc/sys/fs/inotify/max_user_instances\n//\n// To increase them you can use sysctl or write the value to the /proc file:\n//\n//\t# Default values on Linux 5.18\n//\tsysctl fs.inotify.max_user_watches=124983\n//\tsysctl fs.inotify.max_user_instances=128\n//\n// To make the changes persist on reboot edit /etc/sysctl.conf or\n// /usr/lib/sysctl.d/50-default.conf (details differ per Linux distro; check\n// your distro's documentation):\n//\n//\tfs.inotify.max_user_watches=124983\n//\tfs.inotify.max_user_instances=128\n//\n// Reaching the limit will result in a \"no space left on device\" or \"too many open\n// files\" error.\n//\n// # kqueue notes (macOS, BSD)\n//\n// kqueue requires opening a file descriptor for every file that's being watched;\n// so if you're watching a directory with five files then that's six file\n// descriptors. You will run in to your system's \"max open files\" limit faster on\n// these platforms.\n//\n// The sysctl variables kern.maxfiles and kern.maxfilesperproc can be used to\n// control the maximum number of open files, as well as /etc/login.conf on BSD\n// systems.\n//\n// # Windows notes\n//\n// Paths can be added as \"C:\\path\\to\\dir\", but forward slashes\n// (\"C:/path/to/dir\") will also work.\n//\n// When a watched directory is removed it will always send an event for the\n// directory itself, but may not send events for all files in that directory.\n// Sometimes it will send events for all times, sometimes it will send no\n// events, and often only for some files.\n//\n// The default ReadDirectoryChangesW() buffer size is 64K, which is the largest\n// value that is guaranteed to work with SMB filesystems. If you have many\n// events in quick succession this may not be enough, and you will have to use\n// [WithBufferSize] to increase the value.\ntype Watcher struct {\n\t// Events sends the filesystem change events.\n\t//\n\t// fsnotify can send the following events; a \"path\" here can refer to a\n\t// file, directory, symbolic link, or special file like a FIFO.\n\t//\n\t// fsnotify.Create A new path was created; this may be followed by one\n\t// or more Write events if data also gets written to a\n\t// file.\n\t//\n\t// fsnotify.Remove A path was removed.\n\t//\n\t// fsnotify.Rename A path was renamed. A rename is always sent with the\n\t// old path as Event.Name, and a Create event will be\n\t// sent with the new name. Renames are only sent for\n\t// paths that are currently watched; e.g. moving an\n\t// unmonitored file into a monitored directory will\n\t// show up as just a Create. Similarly, renaming a file\n\t// to outside a monitored directory will show up as\n\t// only a Rename.\n\t//\n\t// fsnotify.Write A file or named pipe was written to. A Truncate will\n\t// also trigger a Write. A single \"write action\"\n\t// initiated by the user may show up as one or multiple\n\t// writes, depending on when the system syncs things to\n\t// disk. For example when compiling a large Go program\n\t// you may get hundreds of Write events, and you may\n\t// want to wait until you've stopped receiving them\n\t// (see the dedup example in cmd/fsnotify).\n\t//\n\t// Some systems may send Write event for directories\n\t// when the directory content changes.\n\t//\n\t// fsnotify.Chmod Attributes were changed. On Linux this is also sent\n\t// when a file is removed (or more accurately, when a\n\t// link to an inode is removed). On kqueue it's sent\n\t// when a file is truncated. On Windows it's never\n\t// sent.\n\tEvents chan Event\n\n\t// Errors sends any errors.\n\t//\n\t// ErrEventOverflow is used to indicate there are too many events:\n\t//\n\t// - inotify: There are too many queued events (fs.inotify.max_queued_events sysctl)\n\t// - windows: The buffer size is too small; WithBufferSize() can be used to increase it.\n\t// - kqueue, fen: Not used.\n\tErrors chan error\n\n\t// Store fd here as os.File.Read() will no longer return on close after\n\t// calling Fd(). See: https://github.com/golang/go/issues/26439\n\tfd int\n\tinotifyFile *os.File\n\twatches *watches\n\tdone chan struct{} // Channel for sending a \"quit message\" to the reader goroutine\n\tcloseMu sync.Mutex\n\tdoneResp chan struct{} // Channel to respond to Close\n}\n\ntype (\n\twatches struct {\n\t\tmu sync.RWMutex\n\t\twd map[uint32]*watch // wd → watch\n\t\tpath map[string]uint32 // pathname → wd\n\t}\n\twatch struct {\n\t\twd uint32 // Watch descriptor (as returned by the inotify_add_watch() syscall)\n\t\tflags uint32 // inotify flags of this watch (see inotify(7) for the list of valid flags)\n\t\tpath string // Watch path.\n\t}\n)\n\nfunc newWatches() *watches {\n\treturn &watches{\n\t\twd: make(map[uint32]*watch),\n\t\tpath: make(map[string]uint32),\n\t}\n}\n\nfunc (w *watches) len() int {\n\tw.mu.RLock()\n\tdefer w.mu.RUnlock()\n\treturn len(w.wd)\n}\n\nfunc (w *watches) add(ww *watch) {\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\tw.wd[ww.wd] = ww\n\tw.path[ww.path] = ww.wd\n}\n\nfunc (w *watches) remove(wd uint32) {\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\tdelete(w.path, w.wd[wd].path)\n\tdelete(w.wd, wd)\n}\n\nfunc (w *watches) removePath(path string) (uint32, bool) {\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\n\twd, ok := w.path[path]\n\tif !ok {\n\t\treturn 0, false\n\t}\n\n\tdelete(w.path, path)\n\tdelete(w.wd, wd)\n\n\treturn wd, true\n}\n\nfunc (w *watches) byPath(path string) *watch {\n\tw.mu.RLock()\n\tdefer w.mu.RUnlock()\n\treturn w.wd[w.path[path]]\n}\n\nfunc (w *watches) byWd(wd uint32) *watch {\n\tw.mu.RLock()\n\tdefer w.mu.RUnlock()\n\treturn w.wd[wd]\n}\n\nfunc (w *watches) updatePath(path string, f func(*watch) (*watch, error)) error {\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\n\tvar existing *watch\n\twd, ok := w.path[path]\n\tif ok {\n\t\texisting = w.wd[wd]\n\t}\n\n\tupd, err := f(existing)\n\tif err != nil {\n\t\treturn err\n\t}\n\tif upd != nil {\n\t\tw.wd[upd.wd] = upd\n\t\tw.path[upd.path] = upd.wd\n\n\t\tif upd.wd != wd {\n\t\t\tdelete(w.wd, wd)\n\t\t}\n\t}\n\n\treturn nil\n}\n\n// NewWatcher creates a new Watcher.\nfunc NewWatcher() (*Watcher, error) {\n\treturn NewBufferedWatcher(0)\n}\n\n// NewBufferedWatcher creates a new Watcher with a buffered Watcher.Events\n// channel.\n//\n// The main use case for this is situations with a very large number of events\n// where the kernel buffer size can't be increased (e.g. due to lack of\n// permissions). An unbuffered Watcher will perform better for almost all use\n// cases, and whenever possible you will be better off increasing the kernel\n// buffers instead of adding a large userspace buffer.\nfunc NewBufferedWatcher(sz uint) (*Watcher, error) {\n\t// Need to set nonblocking mode for SetDeadline to work, otherwise blocking\n\t// I/O operations won't terminate on close.\n\tfd, errno := unix.InotifyInit1(unix.IN_CLOEXEC | unix.IN_NONBLOCK)\n\tif fd == -1 {\n\t\treturn nil, errno\n\t}\n\n\tw := &Watcher{\n\t\tfd: fd,\n\t\tinotifyFile: os.NewFile(uintptr(fd), \"\"),\n\t\twatches: newWatches(),\n\t\tEvents: make(chan Event, sz),\n\t\tErrors: make(chan error),\n\t\tdone: make(chan struct{}),\n\t\tdoneResp: make(chan struct{}),\n\t}\n\n\tgo w.readEvents()\n\treturn w, nil\n}\n\n// Returns true if the event was sent, or false if watcher is closed.\nfunc (w *Watcher) sendEvent(e Event) bool {\n\tselect {\n\tcase w.Events <- e:\n\t\treturn true\n\tcase <-w.done:\n\t\treturn false\n\t}\n}\n\n// Returns true if the error was sent, or false if watcher is closed.\nfunc (w *Watcher) sendError(err error) bool {\n\tselect {\n\tcase w.Errors <- err:\n\t\treturn true\n\tcase <-w.done:\n\t\treturn false\n\t}\n}\n\nfunc (w *Watcher) isClosed() bool {\n\tselect {\n\tcase <-w.done:\n\t\treturn true\n\tdefault:\n\t\treturn false\n\t}\n}\n\n// Close removes all watches and closes the Events channel.\nfunc (w *Watcher) Close() error {\n\tw.closeMu.Lock()\n\tif w.isClosed() {\n\t\tw.closeMu.Unlock()\n\t\treturn nil\n\t}\n\tclose(w.done)\n\tw.closeMu.Unlock()\n\n\t// Causes any blocking reads to return with an error, provided the file\n\t// still supports deadline operations.\n\terr := w.inotifyFile.Close()\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t// Wait for goroutine to close\n\t<-w.doneResp\n\n\treturn nil\n}\n\n// Add starts monitoring the path for changes.\n//\n// A path can only be watched once; watching it more than once is a no-op and will\n// not return an error. Paths that do not yet exist on the filesystem cannot be\n// watched.\n//\n// A watch will be automatically removed if the watched path is deleted or\n// renamed. The exception is the Windows backend, which doesn't remove the\n// watcher on renames.\n//\n// Notifications on network filesystems (NFS, SMB, FUSE, etc.) or special\n// filesystems (/proc, /sys, etc.) generally don't work.\n//\n// Returns [ErrClosed] if [Watcher.Close] was called.\n//\n// See [Watcher.AddWith] for a version that allows adding options.\n//\n// # Watching directories\n//\n// All files in a directory are monitored, including new files that are created\n// after the watcher is started. Subdirectories are not watched (i.e. it's\n// non-recursive).\n//\n// # Watching files\n//\n// Watching individual files (rather than directories) is generally not\n// recommended as many programs (especially editors) update files atomically: it\n// will write to a temporary file which is then moved to to destination,\n// overwriting the original (or some variant thereof). The watcher on the\n// original file is now lost, as that no longer exists.\n//\n// The upshot of this is that a power failure or crash won't leave a\n// half-written file.\n//\n// Watch the parent directory and use Event.Name to filter out files you're not\n// interested in. There is an example of this in cmd/fsnotify/file.go.\nfunc (w *Watcher) Add(name string) error { return w.AddWith(name) }\n\n// AddWith is like [Watcher.Add], but allows adding options. When using Add()\n// the defaults described below are used.\n//\n// Possible options are:\n//\n// - [WithBufferSize] sets the buffer size for the Windows backend; no-op on\n// other platforms. The default is 64K (65536 bytes).\nfunc (w *Watcher) AddWith(name string, opts ...addOpt) error {\n\tif w.isClosed() {\n\t\treturn ErrClosed\n\t}\n\n\tname = filepath.Clean(name)\n\t_ = getOptions(opts...)\n\n\tvar flags uint32 = unix.IN_MOVED_TO | unix.IN_MOVED_FROM |\n\t\tunix.IN_CREATE | unix.IN_ATTRIB | unix.IN_MODIFY |\n\t\tunix.IN_MOVE_SELF | unix.IN_DELETE | unix.IN_DELETE_SELF\n\n\treturn w.watches.updatePath(name, func(existing *watch) (*watch, error) {\n\t\tif existing != nil {\n\t\t\tflags |= existing.flags | unix.IN_MASK_ADD\n\t\t}\n\n\t\twd, err := unix.InotifyAddWatch(w.fd, name, flags)\n\t\tif wd == -1 {\n\t\t\treturn nil, err\n\t\t}\n\n\t\tif existing == nil {\n\t\t\treturn &watch{\n\t\t\t\twd: uint32(wd),\n\t\t\t\tpath: name,\n\t\t\t\tflags: flags,\n\t\t\t}, nil\n\t\t}\n\n\t\texisting.wd = uint32(wd)\n\t\texisting.flags = flags\n\t\treturn existing, nil\n\t})\n}\n\n// Remove stops monitoring the path for changes.\n//\n// Directories are always removed non-recursively. For example, if you added\n// /tmp/dir and /tmp/dir/subdir then you will need to remove both.\n//\n// Removing a path that has not yet been added returns [ErrNonExistentWatch].\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) Remove(name string) error {\n\tif w.isClosed() {\n\t\treturn nil\n\t}\n\treturn w.remove(filepath.Clean(name))\n}\n\nfunc (w *Watcher) remove(name string) error {\n\twd, ok := w.watches.removePath(name)\n\tif !ok {\n\t\treturn fmt.Errorf(\"%w: %s\", ErrNonExistentWatch, name)\n\t}\n\n\tsuccess, errno := unix.InotifyRmWatch(w.fd, wd)\n\tif success == -1 {\n\t\t// TODO: Perhaps it's not helpful to return an error here in every case;\n\t\t// The only two possible errors are:\n\t\t//\n\t\t// - EBADF, which happens when w.fd is not a valid file descriptor\n\t\t// of any kind.\n\t\t// - EINVAL, which is when fd is not an inotify descriptor or wd\n\t\t// is not a valid watch descriptor. Watch descriptors are\n\t\t// invalidated when they are removed explicitly or implicitly;\n\t\t// explicitly by inotify_rm_watch, implicitly when the file they\n\t\t// are watching is deleted.\n\t\treturn errno\n\t}\n\treturn nil\n}\n\n// WatchList returns all paths explicitly added with [Watcher.Add] (and are not\n// yet removed).\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) WatchList() []string {\n\tif w.isClosed() {\n\t\treturn nil\n\t}\n\n\tentries := make([]string, 0, w.watches.len())\n\tw.watches.mu.RLock()\n\tfor pathname := range w.watches.path {\n\t\tentries = append(entries, pathname)\n\t}\n\tw.watches.mu.RUnlock()\n\n\treturn entries\n}\n\n// readEvents reads from the inotify file descriptor, converts the\n// received events into Event objects and sends them via the Events channel\nfunc (w *Watcher) readEvents() {\n\tdefer func() {\n\t\tclose(w.doneResp)\n\t\tclose(w.Errors)\n\t\tclose(w.Events)\n\t}()\n\n\tvar (\n\t\tbuf [unix.SizeofInotifyEvent * 4096]byte // Buffer for a maximum of 4096 raw events\n\t\terrno error // Syscall errno\n\t)\n\tfor {\n\t\t// See if we have been closed.\n\t\tif w.isClosed() {\n\t\t\treturn\n\t\t}\n\n\t\tn, err := w.inotifyFile.Read(buf[:])\n\t\tswitch {\n\t\tcase errors.Unwrap(err) == os.ErrClosed:\n\t\t\treturn\n\t\tcase err != nil:\n\t\t\tif !w.sendError(err) {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tcontinue\n\t\t}\n\n\t\tif n < unix.SizeofInotifyEvent {\n\t\t\tvar err error\n\t\t\tif n == 0 {\n\t\t\t\terr = io.EOF // If EOF is received. This should really never happen.\n\t\t\t} else if n < 0 {\n\t\t\t\terr = errno // If an error occurred while reading.\n\t\t\t} else {\n\t\t\t\terr = errors.New(\"notify: short read in readEvents()\") // Read was too short.\n\t\t\t}\n\t\t\tif !w.sendError(err) {\n\t\t\t\treturn\n\t\t\t}\n\t\t\tcontinue\n\t\t}\n\n\t\tvar offset uint32\n\t\t// We don't know how many events we just read into the buffer\n\t\t// While the offset points to at least one whole event...\n\t\tfor offset <= uint32(n-unix.SizeofInotifyEvent) {\n\t\t\tvar (\n\t\t\t\t// Point \"raw\" to the event in the buffer\n\t\t\t\traw = (*unix.InotifyEvent)(unsafe.Pointer(&buf[offset]))\n\t\t\t\tmask = uint32(raw.Mask)\n\t\t\t\tnameLen = uint32(raw.Len)\n\t\t\t)\n\n\t\t\tif mask&unix.IN_Q_OVERFLOW != 0 {\n\t\t\t\tif !w.sendError(ErrEventOverflow) {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// If the event happened to the watched directory or the watched file, the kernel\n\t\t\t// doesn't append the filename to the event, but we would like to always fill the\n\t\t\t// the \"Name\" field with a valid filename. We retrieve the path of the watch from\n\t\t\t// the \"paths\" map.\n\t\t\twatch := w.watches.byWd(uint32(raw.Wd))\n\n\t\t\t// inotify will automatically remove the watch on deletes; just need\n\t\t\t// to clean our state here.\n\t\t\tif watch != nil && mask&unix.IN_DELETE_SELF == unix.IN_DELETE_SELF {\n\t\t\t\tw.watches.remove(watch.wd)\n\t\t\t}\n\t\t\t// We can't really update the state when a watched path is moved;\n\t\t\t// only IN_MOVE_SELF is sent and not IN_MOVED_{FROM,TO}. So remove\n\t\t\t// the watch.\n\t\t\tif watch != nil && mask&unix.IN_MOVE_SELF == unix.IN_MOVE_SELF {\n\t\t\t\terr := w.remove(watch.path)\n\t\t\t\tif err != nil && !errors.Is(err, ErrNonExistentWatch) {\n\t\t\t\t\tif !w.sendError(err) {\n\t\t\t\t\t\treturn\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar name string\n\t\t\tif watch != nil {\n\t\t\t\tname = watch.path\n\t\t\t}\n\t\t\tif nameLen > 0 {\n\t\t\t\t// Point \"bytes\" at the first byte of the filename\n\t\t\t\tbytes := (*[unix.PathMax]byte)(unsafe.Pointer(&buf[offset+unix.SizeofInotifyEvent]))[:nameLen:nameLen]\n\t\t\t\t// The filename is padded with NULL bytes. TrimRight() gets rid of those.\n\t\t\t\tname += \"/\" + strings.TrimRight(string(bytes[0:nameLen]), \"\\000\")\n\t\t\t}\n\n\t\t\tevent := w.newEvent(name, mask)\n\n\t\t\t// Send the events that are not ignored on the events channel\n\t\t\tif mask&unix.IN_IGNORED == 0 {\n\t\t\t\tif !w.sendEvent(event) {\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Move to the next event in the buffer\n\t\t\toffset += unix.SizeofInotifyEvent + nameLen\n\t\t}\n\t}\n}\n\n// newEvent returns an platform-independent Event based on an inotify mask.\nfunc (w *Watcher) newEvent(name string, mask uint32) Event {\n\te := Event{Name: name}\n\tif mask&unix.IN_CREATE == unix.IN_CREATE || mask&unix.IN_MOVED_TO == unix.IN_MOVED_TO {\n\t\te.Op |= Create\n\t}\n\tif mask&unix.IN_DELETE_SELF == unix.IN_DELETE_SELF || mask&unix.IN_DELETE == unix.IN_DELETE {\n\t\te.Op |= Remove\n\t}\n\tif mask&unix.IN_MODIFY == unix.IN_MODIFY {\n\t\te.Op |= Write\n\t}\n\tif mask&unix.IN_MOVE_SELF == unix.IN_MOVE_SELF || mask&unix.IN_MOVED_FROM == unix.IN_MOVED_FROM {\n\t\te.Op |= Rename\n\t}\n\tif mask&unix.IN_ATTRIB == unix.IN_ATTRIB {\n\t\te.Op |= Chmod\n\t}\n\treturn e\n}\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/backend_kqueue.go",
"content": "//go:build freebsd || openbsd || netbsd || dragonfly || darwin\n// +build freebsd openbsd netbsd dragonfly darwin\n\n// Note: the documentation on the Watcher type and methods is generated from\n// mkdoc.zsh\n\npackage fsnotify\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"sync\"\n\n\t\"golang.org/x/sys/unix\"\n)\n\n// Watcher watches a set of paths, delivering events on a channel.\n//\n// A watcher should not be copied (e.g. pass it by pointer, rather than by\n// value).\n//\n// # Linux notes\n//\n// When a file is removed a Remove event won't be emitted until all file\n// descriptors are closed, and deletes will always emit a Chmod. For example:\n//\n//\tfp := os.Open(\"file\")\n//\tos.Remove(\"file\") // Triggers Chmod\n//\tfp.Close() // Triggers Remove\n//\n// This is the event that inotify sends, so not much can be changed about this.\n//\n// The fs.inotify.max_user_watches sysctl variable specifies the upper limit\n// for the number of watches per user, and fs.inotify.max_user_instances\n// specifies the maximum number of inotify instances per user. Every Watcher you\n// create is an \"instance\", and every path you add is a \"watch\".\n//\n// These are also exposed in /proc as /proc/sys/fs/inotify/max_user_watches and\n// /proc/sys/fs/inotify/max_user_instances\n//\n// To increase them you can use sysctl or write the value to the /proc file:\n//\n//\t# Default values on Linux 5.18\n//\tsysctl fs.inotify.max_user_watches=124983\n//\tsysctl fs.inotify.max_user_instances=128\n//\n// To make the changes persist on reboot edit /etc/sysctl.conf or\n// /usr/lib/sysctl.d/50-default.conf (details differ per Linux distro; check\n// your distro's documentation):\n//\n//\tfs.inotify.max_user_watches=124983\n//\tfs.inotify.max_user_instances=128\n//\n// Reaching the limit will result in a \"no space left on device\" or \"too many open\n// files\" error.\n//\n// # kqueue notes (macOS, BSD)\n//\n// kqueue requires opening a file descriptor for every file that's being watched;\n// so if you're watching a directory with five files then that's six file\n// descriptors. You will run in to your system's \"max open files\" limit faster on\n// these platforms.\n//\n// The sysctl variables kern.maxfiles and kern.maxfilesperproc can be used to\n// control the maximum number of open files, as well as /etc/login.conf on BSD\n// systems.\n//\n// # Windows notes\n//\n// Paths can be added as \"C:\\path\\to\\dir\", but forward slashes\n// (\"C:/path/to/dir\") will also work.\n//\n// When a watched directory is removed it will always send an event for the\n// directory itself, but may not send events for all files in that directory.\n// Sometimes it will send events for all times, sometimes it will send no\n// events, and often only for some files.\n//\n// The default ReadDirectoryChangesW() buffer size is 64K, which is the largest\n// value that is guaranteed to work with SMB filesystems. If you have many\n// events in quick succession this may not be enough, and you will have to use\n// [WithBufferSize] to increase the value.\ntype Watcher struct {\n\t// Events sends the filesystem change events.\n\t//\n\t// fsnotify can send the following events; a \"path\" here can refer to a\n\t// file, directory, symbolic link, or special file like a FIFO.\n\t//\n\t// fsnotify.Create A new path was created; this may be followed by one\n\t// or more Write events if data also gets written to a\n\t// file.\n\t//\n\t// fsnotify.Remove A path was removed.\n\t//\n\t// fsnotify.Rename A path was renamed. A rename is always sent with the\n\t// old path as Event.Name, and a Create event will be\n\t// sent with the new name. Renames are only sent for\n\t// paths that are currently watched; e.g. moving an\n\t// unmonitored file into a monitored directory will\n\t// show up as just a Create. Similarly, renaming a file\n\t// to outside a monitored directory will show up as\n\t// only a Rename.\n\t//\n\t// fsnotify.Write A file or named pipe was written to. A Truncate will\n\t// also trigger a Write. A single \"write action\"\n\t// initiated by the user may show up as one or multiple\n\t// writes, depending on when the system syncs things to\n\t// disk. For example when compiling a large Go program\n\t// you may get hundreds of Write events, and you may\n\t// want to wait until you've stopped receiving them\n\t// (see the dedup example in cmd/fsnotify).\n\t//\n\t// Some systems may send Write event for directories\n\t// when the directory content changes.\n\t//\n\t// fsnotify.Chmod Attributes were changed. On Linux this is also sent\n\t// when a file is removed (or more accurately, when a\n\t// link to an inode is removed). On kqueue it's sent\n\t// when a file is truncated. On Windows it's never\n\t// sent.\n\tEvents chan Event\n\n\t// Errors sends any errors.\n\t//\n\t// ErrEventOverflow is used to indicate there are too many events:\n\t//\n\t// - inotify: There are too many queued events (fs.inotify.max_queued_events sysctl)\n\t// - windows: The buffer size is too small; WithBufferSize() can be used to increase it.\n\t// - kqueue, fen: Not used.\n\tErrors chan error\n\n\tdone chan struct{}\n\tkq int // File descriptor (as returned by the kqueue() syscall).\n\tclosepipe [2]int // Pipe used for closing.\n\tmu sync.Mutex // Protects access to watcher data\n\twatches map[string]int // Watched file descriptors (key: path).\n\twatchesByDir map[string]map[int]struct{} // Watched file descriptors indexed by the parent directory (key: dirname(path)).\n\tuserWatches map[string]struct{} // Watches added with Watcher.Add()\n\tdirFlags map[string]uint32 // Watched directories to fflags used in kqueue.\n\tpaths map[int]pathInfo // File descriptors to path names for processing kqueue events.\n\tfileExists map[string]struct{} // Keep track of if we know this file exists (to stop duplicate create events).\n\tisClosed bool // Set to true when Close() is first called\n}\n\ntype pathInfo struct {\n\tname string\n\tisDir bool\n}\n\n// NewWatcher creates a new Watcher.\nfunc NewWatcher() (*Watcher, error) {\n\treturn NewBufferedWatcher(0)\n}\n\n// NewBufferedWatcher creates a new Watcher with a buffered Watcher.Events\n// channel.\n//\n// The main use case for this is situations with a very large number of events\n// where the kernel buffer size can't be increased (e.g. due to lack of\n// permissions). An unbuffered Watcher will perform better for almost all use\n// cases, and whenever possible you will be better off increasing the kernel\n// buffers instead of adding a large userspace buffer.\nfunc NewBufferedWatcher(sz uint) (*Watcher, error) {\n\tkq, closepipe, err := newKqueue()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tw := &Watcher{\n\t\tkq: kq,\n\t\tclosepipe: closepipe,\n\t\twatches: make(map[string]int),\n\t\twatchesByDir: make(map[string]map[int]struct{}),\n\t\tdirFlags: make(map[string]uint32),\n\t\tpaths: make(map[int]pathInfo),\n\t\tfileExists: make(map[string]struct{}),\n\t\tuserWatches: make(map[string]struct{}),\n\t\tEvents: make(chan Event, sz),\n\t\tErrors: make(chan error),\n\t\tdone: make(chan struct{}),\n\t}\n\n\tgo w.readEvents()\n\treturn w, nil\n}\n\n// newKqueue creates a new kernel event queue and returns a descriptor.\n//\n// This registers a new event on closepipe, which will trigger an event when\n// it's closed. This way we can use kevent() without timeout/polling; without\n// the closepipe, it would block forever and we wouldn't be able to stop it at\n// all.\nfunc newKqueue() (kq int, closepipe [2]int, err error) {\n\tkq, err = unix.Kqueue()\n\tif kq == -1 {\n\t\treturn kq, closepipe, err\n\t}\n\n\t// Register the close pipe.\n\terr = unix.Pipe(closepipe[:])\n\tif err != nil {\n\t\tunix.Close(kq)\n\t\treturn kq, closepipe, err\n\t}\n\n\t// Register changes to listen on the closepipe.\n\tchanges := make([]unix.Kevent_t, 1)\n\t// SetKevent converts int to the platform-specific types.\n\tunix.SetKevent(&changes[0], closepipe[0], unix.EVFILT_READ,\n\t\tunix.EV_ADD|unix.EV_ENABLE|unix.EV_ONESHOT)\n\n\tok, err := unix.Kevent(kq, changes, nil, nil)\n\tif ok == -1 {\n\t\tunix.Close(kq)\n\t\tunix.Close(closepipe[0])\n\t\tunix.Close(closepipe[1])\n\t\treturn kq, closepipe, err\n\t}\n\treturn kq, closepipe, nil\n}\n\n// Returns true if the event was sent, or false if watcher is closed.\nfunc (w *Watcher) sendEvent(e Event) bool {\n\tselect {\n\tcase w.Events <- e:\n\t\treturn true\n\tcase <-w.done:\n\t\treturn false\n\t}\n}\n\n// Returns true if the error was sent, or false if watcher is closed.\nfunc (w *Watcher) sendError(err error) bool {\n\tselect {\n\tcase w.Errors <- err:\n\t\treturn true\n\tcase <-w.done:\n\t\treturn false\n\t}\n}\n\n// Close removes all watches and closes the Events channel.\nfunc (w *Watcher) Close() error {\n\tw.mu.Lock()\n\tif w.isClosed {\n\t\tw.mu.Unlock()\n\t\treturn nil\n\t}\n\tw.isClosed = true\n\n\t// copy paths to remove while locked\n\tpathsToRemove := make([]string, 0, len(w.watches))\n\tfor name := range w.watches {\n\t\tpathsToRemove = append(pathsToRemove, name)\n\t}\n\tw.mu.Unlock() // Unlock before calling Remove, which also locks\n\tfor _, name := range pathsToRemove {\n\t\tw.Remove(name)\n\t}\n\n\t// Send \"quit\" message to the reader goroutine.\n\tunix.Close(w.closepipe[1])\n\tclose(w.done)\n\n\treturn nil\n}\n\n// Add starts monitoring the path for changes.\n//\n// A path can only be watched once; watching it more than once is a no-op and will\n// not return an error. Paths that do not yet exist on the filesystem cannot be\n// watched.\n//\n// A watch will be automatically removed if the watched path is deleted or\n// renamed. The exception is the Windows backend, which doesn't remove the\n// watcher on renames.\n//\n// Notifications on network filesystems (NFS, SMB, FUSE, etc.) or special\n// filesystems (/proc, /sys, etc.) generally don't work.\n//\n// Returns [ErrClosed] if [Watcher.Close] was called.\n//\n// See [Watcher.AddWith] for a version that allows adding options.\n//\n// # Watching directories\n//\n// All files in a directory are monitored, including new files that are created\n// after the watcher is started. Subdirectories are not watched (i.e. it's\n// non-recursive).\n//\n// # Watching files\n//\n// Watching individual files (rather than directories) is generally not\n// recommended as many programs (especially editors) update files atomically: it\n// will write to a temporary file which is then moved to to destination,\n// overwriting the original (or some variant thereof). The watcher on the\n// original file is now lost, as that no longer exists.\n//\n// The upshot of this is that a power failure or crash won't leave a\n// half-written file.\n//\n// Watch the parent directory and use Event.Name to filter out files you're not\n// interested in. There is an example of this in cmd/fsnotify/file.go.\nfunc (w *Watcher) Add(name string) error { return w.AddWith(name) }\n\n// AddWith is like [Watcher.Add], but allows adding options. When using Add()\n// the defaults described below are used.\n//\n// Possible options are:\n//\n// - [WithBufferSize] sets the buffer size for the Windows backend; no-op on\n// other platforms. The default is 64K (65536 bytes).\nfunc (w *Watcher) AddWith(name string, opts ...addOpt) error {\n\t_ = getOptions(opts...)\n\n\tw.mu.Lock()\n\tw.userWatches[name] = struct{}{}\n\tw.mu.Unlock()\n\t_, err := w.addWatch(name, noteAllEvents)\n\treturn err\n}\n\n// Remove stops monitoring the path for changes.\n//\n// Directories are always removed non-recursively. For example, if you added\n// /tmp/dir and /tmp/dir/subdir then you will need to remove both.\n//\n// Removing a path that has not yet been added returns [ErrNonExistentWatch].\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) Remove(name string) error {\n\treturn w.remove(name, true)\n}\n\nfunc (w *Watcher) remove(name string, unwatchFiles bool) error {\n\tname = filepath.Clean(name)\n\tw.mu.Lock()\n\tif w.isClosed {\n\t\tw.mu.Unlock()\n\t\treturn nil\n\t}\n\twatchfd, ok := w.watches[name]\n\tw.mu.Unlock()\n\tif !ok {\n\t\treturn fmt.Errorf(\"%w: %s\", ErrNonExistentWatch, name)\n\t}\n\n\terr := w.register([]int{watchfd}, unix.EV_DELETE, 0)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tunix.Close(watchfd)\n\n\tw.mu.Lock()\n\tisDir := w.paths[watchfd].isDir\n\tdelete(w.watches, name)\n\tdelete(w.userWatches, name)\n\n\tparentName := filepath.Dir(name)\n\tdelete(w.watchesByDir[parentName], watchfd)\n\n\tif len(w.watchesByDir[parentName]) == 0 {\n\t\tdelete(w.watchesByDir, parentName)\n\t}\n\n\tdelete(w.paths, watchfd)\n\tdelete(w.dirFlags, name)\n\tdelete(w.fileExists, name)\n\tw.mu.Unlock()\n\n\t// Find all watched paths that are in this directory that are not external.\n\tif unwatchFiles && isDir {\n\t\tvar pathsToRemove []string\n\t\tw.mu.Lock()\n\t\tfor fd := range w.watchesByDir[name] {\n\t\t\tpath := w.paths[fd]\n\t\t\tif _, ok := w.userWatches[path.name]; !ok {\n\t\t\t\tpathsToRemove = append(pathsToRemove, path.name)\n\t\t\t}\n\t\t}\n\t\tw.mu.Unlock()\n\t\tfor _, name := range pathsToRemove {\n\t\t\t// Since these are internal, not much sense in propagating error to\n\t\t\t// the user, as that will just confuse them with an error about a\n\t\t\t// path they did not explicitly watch themselves.\n\t\t\tw.Remove(name)\n\t\t}\n\t}\n\treturn nil\n}\n\n// WatchList returns all paths explicitly added with [Watcher.Add] (and are not\n// yet removed).\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) WatchList() []string {\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\tif w.isClosed {\n\t\treturn nil\n\t}\n\n\tentries := make([]string, 0, len(w.userWatches))\n\tfor pathname := range w.userWatches {\n\t\tentries = append(entries, pathname)\n\t}\n\n\treturn entries\n}\n\n// Watch all events (except NOTE_EXTEND, NOTE_LINK, NOTE_REVOKE)\nconst noteAllEvents = unix.NOTE_DELETE | unix.NOTE_WRITE | unix.NOTE_ATTRIB | unix.NOTE_RENAME\n\n// addWatch adds name to the watched file set; the flags are interpreted as\n// described in kevent(2).\n//\n// Returns the real path to the file which was added, with symlinks resolved.\nfunc (w *Watcher) addWatch(name string, flags uint32) (string, error) {\n\tvar isDir bool\n\tname = filepath.Clean(name)\n\n\tw.mu.Lock()\n\tif w.isClosed {\n\t\tw.mu.Unlock()\n\t\treturn \"\", ErrClosed\n\t}\n\twatchfd, alreadyWatching := w.watches[name]\n\t// We already have a watch, but we can still override flags.\n\tif alreadyWatching {\n\t\tisDir = w.paths[watchfd].isDir\n\t}\n\tw.mu.Unlock()\n\n\tif !alreadyWatching {\n\t\tfi, err := os.Lstat(name)\n\t\tif err != nil {\n\t\t\treturn \"\", err\n\t\t}\n\n\t\t// Don't watch sockets or named pipes\n\t\tif (fi.Mode()&os.ModeSocket == os.ModeSocket) || (fi.Mode()&os.ModeNamedPipe == os.ModeNamedPipe) {\n\t\t\treturn \"\", nil\n\t\t}\n\n\t\t// Follow Symlinks.\n\t\tif fi.Mode()&os.ModeSymlink == os.ModeSymlink {\n\t\t\tlink, err := os.Readlink(name)\n\t\t\tif err != nil {\n\t\t\t\t// Return nil because Linux can add unresolvable symlinks to the\n\t\t\t\t// watch list without problems, so maintain consistency with\n\t\t\t\t// that. There will be no file events for broken symlinks.\n\t\t\t\t// TODO: more specific check; returns os.PathError; ENOENT?\n\t\t\t\treturn \"\", nil\n\t\t\t}\n\n\t\t\tw.mu.Lock()\n\t\t\t_, alreadyWatching = w.watches[link]\n\t\t\tw.mu.Unlock()\n\n\t\t\tif alreadyWatching {\n\t\t\t\t// Add to watches so we don't get spurious Create events later\n\t\t\t\t// on when we diff the directories.\n\t\t\t\tw.watches[name] = 0\n\t\t\t\tw.fileExists[name] = struct{}{}\n\t\t\t\treturn link, nil\n\t\t\t}\n\n\t\t\tname = link\n\t\t\tfi, err = os.Lstat(name)\n\t\t\tif err != nil {\n\t\t\t\treturn \"\", nil\n\t\t\t}\n\t\t}\n\n\t\t// Retry on EINTR; open() can return EINTR in practice on macOS.\n\t\t// See #354, and Go issues 11180 and 39237.\n\t\tfor {\n\t\t\twatchfd, err = unix.Open(name, openMode, 0)\n\t\t\tif err == nil {\n\t\t\t\tbreak\n\t\t\t}\n\t\t\tif errors.Is(err, unix.EINTR) {\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\treturn \"\", err\n\t\t}\n\n\t\tisDir = fi.IsDir()\n\t}\n\n\terr := w.register([]int{watchfd}, unix.EV_ADD|unix.EV_CLEAR|unix.EV_ENABLE, flags)\n\tif err != nil {\n\t\tunix.Close(watchfd)\n\t\treturn \"\", err\n\t}\n\n\tif !alreadyWatching {\n\t\tw.mu.Lock()\n\t\tparentName := filepath.Dir(name)\n\t\tw.watches[name] = watchfd\n\n\t\twatchesByDir, ok := w.watchesByDir[parentName]\n\t\tif !ok {\n\t\t\twatchesByDir = make(map[int]struct{}, 1)\n\t\t\tw.watchesByDir[parentName] = watchesByDir\n\t\t}\n\t\twatchesByDir[watchfd] = struct{}{}\n\t\tw.paths[watchfd] = pathInfo{name: name, isDir: isDir}\n\t\tw.mu.Unlock()\n\t}\n\n\tif isDir {\n\t\t// Watch the directory if it has not been watched before, or if it was\n\t\t// watched before, but perhaps only a NOTE_DELETE (watchDirectoryFiles)\n\t\tw.mu.Lock()\n\n\t\twatchDir := (flags&unix.NOTE_WRITE) == unix.NOTE_WRITE &&\n\t\t\t(!alreadyWatching || (w.dirFlags[name]&unix.NOTE_WRITE) != unix.NOTE_WRITE)\n\t\t// Store flags so this watch can be updated later\n\t\tw.dirFlags[name] = flags\n\t\tw.mu.Unlock()\n\n\t\tif watchDir {\n\t\t\tif err := w.watchDirectoryFiles(name); err != nil {\n\t\t\t\treturn \"\", err\n\t\t\t}\n\t\t}\n\t}\n\treturn name, nil\n}\n\n// readEvents reads from kqueue and converts the received kevents into\n// Event values that it sends down the Events channel.\nfunc (w *Watcher) readEvents() {\n\tdefer func() {\n\t\tclose(w.Events)\n\t\tclose(w.Errors)\n\t\t_ = unix.Close(w.kq)\n\t\tunix.Close(w.closepipe[0])\n\t}()\n\n\teventBuffer := make([]unix.Kevent_t, 10)\n\tfor closed := false; !closed; {\n\t\tkevents, err := w.read(eventBuffer)\n\t\t// EINTR is okay, the syscall was interrupted before timeout expired.\n\t\tif err != nil && err != unix.EINTR {\n\t\t\tif !w.sendError(fmt.Errorf(\"fsnotify.readEvents: %w\", err)) {\n\t\t\t\tclosed = true\n\t\t\t}\n\t\t\tcontinue\n\t\t}\n\n\t\t// Flush the events we received to the Events channel\n\t\tfor _, kevent := range kevents {\n\t\t\tvar (\n\t\t\t\twatchfd = int(kevent.Ident)\n\t\t\t\tmask = uint32(kevent.Fflags)\n\t\t\t)\n\n\t\t\t// Shut down the loop when the pipe is closed, but only after all\n\t\t\t// other events have been processed.\n\t\t\tif watchfd == w.closepipe[0] {\n\t\t\t\tclosed = true\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tw.mu.Lock()\n\t\t\tpath := w.paths[watchfd]\n\t\t\tw.mu.Unlock()\n\n\t\t\tevent := w.newEvent(path.name, mask)\n\n\t\t\tif event.Has(Rename) || event.Has(Remove) {\n\t\t\t\tw.remove(event.Name, false)\n\t\t\t\tw.mu.Lock()\n\t\t\t\tdelete(w.fileExists, event.Name)\n\t\t\t\tw.mu.Unlock()\n\t\t\t}\n\n\t\t\tif path.isDir && event.Has(Write) && !event.Has(Remove) {\n\t\t\t\tw.sendDirectoryChangeEvents(event.Name)\n\t\t\t} else {\n\t\t\t\tif !w.sendEvent(event) {\n\t\t\t\t\tclosed = true\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif event.Has(Remove) {\n\t\t\t\t// Look for a file that may have overwritten this; for example,\n\t\t\t\t// mv f1 f2 will delete f2, then create f2.\n\t\t\t\tif path.isDir {\n\t\t\t\t\tfileDir := filepath.Clean(event.Name)\n\t\t\t\t\tw.mu.Lock()\n\t\t\t\t\t_, found := w.watches[fileDir]\n\t\t\t\t\tw.mu.Unlock()\n\t\t\t\t\tif found {\n\t\t\t\t\t\terr := w.sendDirectoryChangeEvents(fileDir)\n\t\t\t\t\t\tif err != nil {\n\t\t\t\t\t\t\tif !w.sendError(err) {\n\t\t\t\t\t\t\t\tclosed = true\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tfilePath := filepath.Clean(event.Name)\n\t\t\t\t\tif fi, err := os.Lstat(filePath); err == nil {\n\t\t\t\t\t\terr := w.sendFileCreatedEventIfNew(filePath, fi)\n\t\t\t\t\t\tif err != nil {\n\t\t\t\t\t\t\tif !w.sendError(err) {\n\t\t\t\t\t\t\t\tclosed = true\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n// newEvent returns an platform-independent Event based on kqueue Fflags.\nfunc (w *Watcher) newEvent(name string, mask uint32) Event {\n\te := Event{Name: name}\n\tif mask&unix.NOTE_DELETE == unix.NOTE_DELETE {\n\t\te.Op |= Remove\n\t}\n\tif mask&unix.NOTE_WRITE == unix.NOTE_WRITE {\n\t\te.Op |= Write\n\t}\n\tif mask&unix.NOTE_RENAME == unix.NOTE_RENAME {\n\t\te.Op |= Rename\n\t}\n\tif mask&unix.NOTE_ATTRIB == unix.NOTE_ATTRIB {\n\t\te.Op |= Chmod\n\t}\n\t// No point sending a write and delete event at the same time: if it's gone,\n\t// then it's gone.\n\tif e.Op.Has(Write) && e.Op.Has(Remove) {\n\t\te.Op &^= Write\n\t}\n\treturn e\n}\n\n// watchDirectoryFiles to mimic inotify when adding a watch on a directory\nfunc (w *Watcher) watchDirectoryFiles(dirPath string) error {\n\t// Get all files\n\tfiles, err := os.ReadDir(dirPath)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tfor _, f := range files {\n\t\tpath := filepath.Join(dirPath, f.Name())\n\n\t\tfi, err := f.Info()\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"%q: %w\", path, err)\n\t\t}\n\n\t\tcleanPath, err := w.internalWatch(path, fi)\n\t\tif err != nil {\n\t\t\t// No permission to read the file; that's not a problem: just skip.\n\t\t\t// But do add it to w.fileExists to prevent it from being picked up\n\t\t\t// as a \"new\" file later (it still shows up in the directory\n\t\t\t// listing).\n\t\t\tswitch {\n\t\t\tcase errors.Is(err, unix.EACCES) || errors.Is(err, unix.EPERM):\n\t\t\t\tcleanPath = filepath.Clean(path)\n\t\t\tdefault:\n\t\t\t\treturn fmt.Errorf(\"%q: %w\", path, err)\n\t\t\t}\n\t\t}\n\n\t\tw.mu.Lock()\n\t\tw.fileExists[cleanPath] = struct{}{}\n\t\tw.mu.Unlock()\n\t}\n\n\treturn nil\n}\n\n// Search the directory for new files and send an event for them.\n//\n// This functionality is to have the BSD watcher match the inotify, which sends\n// a create event for files created in a watched directory.\nfunc (w *Watcher) sendDirectoryChangeEvents(dir string) error {\n\tfiles, err := os.ReadDir(dir)\n\tif err != nil {\n\t\t// Directory no longer exists: we can ignore this safely. kqueue will\n\t\t// still give us the correct events.\n\t\tif errors.Is(err, os.ErrNotExist) {\n\t\t\treturn nil\n\t\t}\n\t\treturn fmt.Errorf(\"fsnotify.sendDirectoryChangeEvents: %w\", err)\n\t}\n\n\tfor _, f := range files {\n\t\tfi, err := f.Info()\n\t\tif err != nil {\n\t\t\treturn fmt.Errorf(\"fsnotify.sendDirectoryChangeEvents: %w\", err)\n\t\t}\n\n\t\terr = w.sendFileCreatedEventIfNew(filepath.Join(dir, fi.Name()), fi)\n\t\tif err != nil {\n\t\t\t// Don't need to send an error if this file isn't readable.\n\t\t\tif errors.Is(err, unix.EACCES) || errors.Is(err, unix.EPERM) {\n\t\t\t\treturn nil\n\t\t\t}\n\t\t\treturn fmt.Errorf(\"fsnotify.sendDirectoryChangeEvents: %w\", err)\n\t\t}\n\t}\n\treturn nil\n}\n\n// sendFileCreatedEvent sends a create event if the file isn't already being tracked.\nfunc (w *Watcher) sendFileCreatedEventIfNew(filePath string, fi os.FileInfo) (err error) {\n\tw.mu.Lock()\n\t_, doesExist := w.fileExists[filePath]\n\tw.mu.Unlock()\n\tif !doesExist {\n\t\tif !w.sendEvent(Event{Name: filePath, Op: Create}) {\n\t\t\treturn\n\t\t}\n\t}\n\n\t// like watchDirectoryFiles (but without doing another ReadDir)\n\tfilePath, err = w.internalWatch(filePath, fi)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tw.mu.Lock()\n\tw.fileExists[filePath] = struct{}{}\n\tw.mu.Unlock()\n\n\treturn nil\n}\n\nfunc (w *Watcher) internalWatch(name string, fi os.FileInfo) (string, error) {\n\tif fi.IsDir() {\n\t\t// mimic Linux providing delete events for subdirectories, but preserve\n\t\t// the flags used if currently watching subdirectory\n\t\tw.mu.Lock()\n\t\tflags := w.dirFlags[name]\n\t\tw.mu.Unlock()\n\n\t\tflags |= unix.NOTE_DELETE | unix.NOTE_RENAME\n\t\treturn w.addWatch(name, flags)\n\t}\n\n\t// watch file to mimic Linux inotify\n\treturn w.addWatch(name, noteAllEvents)\n}\n\n// Register events with the queue.\nfunc (w *Watcher) register(fds []int, flags int, fflags uint32) error {\n\tchanges := make([]unix.Kevent_t, len(fds))\n\tfor i, fd := range fds {\n\t\t// SetKevent converts int to the platform-specific types.\n\t\tunix.SetKevent(&changes[i], fd, unix.EVFILT_VNODE, flags)\n\t\tchanges[i].Fflags = fflags\n\t}\n\n\t// Register the events.\n\tsuccess, err := unix.Kevent(w.kq, changes, nil, nil)\n\tif success == -1 {\n\t\treturn err\n\t}\n\treturn nil\n}\n\n// read retrieves pending events, or waits until an event occurs.\nfunc (w *Watcher) read(events []unix.Kevent_t) ([]unix.Kevent_t, error) {\n\tn, err := unix.Kevent(w.kq, nil, events, nil)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn events[0:n], nil\n}\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/backend_other.go",
"content": "//go:build appengine || (!darwin && !dragonfly && !freebsd && !openbsd && !linux && !netbsd && !solaris && !windows)\n// +build appengine !darwin,!dragonfly,!freebsd,!openbsd,!linux,!netbsd,!solaris,!windows\n\n// Note: the documentation on the Watcher type and methods is generated from\n// mkdoc.zsh\n\npackage fsnotify\n\nimport \"errors\"\n\n// Watcher watches a set of paths, delivering events on a channel.\n//\n// A watcher should not be copied (e.g. pass it by pointer, rather than by\n// value).\n//\n// # Linux notes\n//\n// When a file is removed a Remove event won't be emitted until all file\n// descriptors are closed, and deletes will always emit a Chmod. For example:\n//\n//\tfp := os.Open(\"file\")\n//\tos.Remove(\"file\") // Triggers Chmod\n//\tfp.Close() // Triggers Remove\n//\n// This is the event that inotify sends, so not much can be changed about this.\n//\n// The fs.inotify.max_user_watches sysctl variable specifies the upper limit\n// for the number of watches per user, and fs.inotify.max_user_instances\n// specifies the maximum number of inotify instances per user. Every Watcher you\n// create is an \"instance\", and every path you add is a \"watch\".\n//\n// These are also exposed in /proc as /proc/sys/fs/inotify/max_user_watches and\n// /proc/sys/fs/inotify/max_user_instances\n//\n// To increase them you can use sysctl or write the value to the /proc file:\n//\n//\t# Default values on Linux 5.18\n//\tsysctl fs.inotify.max_user_watches=124983\n//\tsysctl fs.inotify.max_user_instances=128\n//\n// To make the changes persist on reboot edit /etc/sysctl.conf or\n// /usr/lib/sysctl.d/50-default.conf (details differ per Linux distro; check\n// your distro's documentation):\n//\n//\tfs.inotify.max_user_watches=124983\n//\tfs.inotify.max_user_instances=128\n//\n// Reaching the limit will result in a \"no space left on device\" or \"too many open\n// files\" error.\n//\n// # kqueue notes (macOS, BSD)\n//\n// kqueue requires opening a file descriptor for every file that's being watched;\n// so if you're watching a directory with five files then that's six file\n// descriptors. You will run in to your system's \"max open files\" limit faster on\n// these platforms.\n//\n// The sysctl variables kern.maxfiles and kern.maxfilesperproc can be used to\n// control the maximum number of open files, as well as /etc/login.conf on BSD\n// systems.\n//\n// # Windows notes\n//\n// Paths can be added as \"C:\\path\\to\\dir\", but forward slashes\n// (\"C:/path/to/dir\") will also work.\n//\n// When a watched directory is removed it will always send an event for the\n// directory itself, but may not send events for all files in that directory.\n// Sometimes it will send events for all times, sometimes it will send no\n// events, and often only for some files.\n//\n// The default ReadDirectoryChangesW() buffer size is 64K, which is the largest\n// value that is guaranteed to work with SMB filesystems. If you have many\n// events in quick succession this may not be enough, and you will have to use\n// [WithBufferSize] to increase the value.\ntype Watcher struct {\n\t// Events sends the filesystem change events.\n\t//\n\t// fsnotify can send the following events; a \"path\" here can refer to a\n\t// file, directory, symbolic link, or special file like a FIFO.\n\t//\n\t// fsnotify.Create A new path was created; this may be followed by one\n\t// or more Write events if data also gets written to a\n\t// file.\n\t//\n\t// fsnotify.Remove A path was removed.\n\t//\n\t// fsnotify.Rename A path was renamed. A rename is always sent with the\n\t// old path as Event.Name, and a Create event will be\n\t// sent with the new name. Renames are only sent for\n\t// paths that are currently watched; e.g. moving an\n\t// unmonitored file into a monitored directory will\n\t// show up as just a Create. Similarly, renaming a file\n\t// to outside a monitored directory will show up as\n\t// only a Rename.\n\t//\n\t// fsnotify.Write A file or named pipe was written to. A Truncate will\n\t// also trigger a Write. A single \"write action\"\n\t// initiated by the user may show up as one or multiple\n\t// writes, depending on when the system syncs things to\n\t// disk. For example when compiling a large Go program\n\t// you may get hundreds of Write events, and you may\n\t// want to wait until you've stopped receiving them\n\t// (see the dedup example in cmd/fsnotify).\n\t//\n\t// Some systems may send Write event for directories\n\t// when the directory content changes.\n\t//\n\t// fsnotify.Chmod Attributes were changed. On Linux this is also sent\n\t// when a file is removed (or more accurately, when a\n\t// link to an inode is removed). On kqueue it's sent\n\t// when a file is truncated. On Windows it's never\n\t// sent.\n\tEvents chan Event\n\n\t// Errors sends any errors.\n\t//\n\t// ErrEventOverflow is used to indicate there are too many events:\n\t//\n\t// - inotify: There are too many queued events (fs.inotify.max_queued_events sysctl)\n\t// - windows: The buffer size is too small; WithBufferSize() can be used to increase it.\n\t// - kqueue, fen: Not used.\n\tErrors chan error\n}\n\n// NewWatcher creates a new Watcher.\nfunc NewWatcher() (*Watcher, error) {\n\treturn nil, errors.New(\"fsnotify not supported on the current platform\")\n}\n\n// NewBufferedWatcher creates a new Watcher with a buffered Watcher.Events\n// channel.\n//\n// The main use case for this is situations with a very large number of events\n// where the kernel buffer size can't be increased (e.g. due to lack of\n// permissions). An unbuffered Watcher will perform better for almost all use\n// cases, and whenever possible you will be better off increasing the kernel\n// buffers instead of adding a large userspace buffer.\nfunc NewBufferedWatcher(sz uint) (*Watcher, error) { return NewWatcher() }\n\n// Close removes all watches and closes the Events channel.\nfunc (w *Watcher) Close() error { return nil }\n\n// WatchList returns all paths explicitly added with [Watcher.Add] (and are not\n// yet removed).\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) WatchList() []string { return nil }\n\n// Add starts monitoring the path for changes.\n//\n// A path can only be watched once; watching it more than once is a no-op and will\n// not return an error. Paths that do not yet exist on the filesystem cannot be\n// watched.\n//\n// A watch will be automatically removed if the watched path is deleted or\n// renamed. The exception is the Windows backend, which doesn't remove the\n// watcher on renames.\n//\n// Notifications on network filesystems (NFS, SMB, FUSE, etc.) or special\n// filesystems (/proc, /sys, etc.) generally don't work.\n//\n// Returns [ErrClosed] if [Watcher.Close] was called.\n//\n// See [Watcher.AddWith] for a version that allows adding options.\n//\n// # Watching directories\n//\n// All files in a directory are monitored, including new files that are created\n// after the watcher is started. Subdirectories are not watched (i.e. it's\n// non-recursive).\n//\n// # Watching files\n//\n// Watching individual files (rather than directories) is generally not\n// recommended as many programs (especially editors) update files atomically: it\n// will write to a temporary file which is then moved to to destination,\n// overwriting the original (or some variant thereof). The watcher on the\n// original file is now lost, as that no longer exists.\n//\n// The upshot of this is that a power failure or crash won't leave a\n// half-written file.\n//\n// Watch the parent directory and use Event.Name to filter out files you're not\n// interested in. There is an example of this in cmd/fsnotify/file.go.\nfunc (w *Watcher) Add(name string) error { return nil }\n\n// AddWith is like [Watcher.Add], but allows adding options. When using Add()\n// the defaults described below are used.\n//\n// Possible options are:\n//\n// - [WithBufferSize] sets the buffer size for the Windows backend; no-op on\n// other platforms. The default is 64K (65536 bytes).\nfunc (w *Watcher) AddWith(name string, opts ...addOpt) error { return nil }\n\n// Remove stops monitoring the path for changes.\n//\n// Directories are always removed non-recursively. For example, if you added\n// /tmp/dir and /tmp/dir/subdir then you will need to remove both.\n//\n// Removing a path that has not yet been added returns [ErrNonExistentWatch].\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) Remove(name string) error { return nil }\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/backend_windows.go",
"content": "//go:build windows\n// +build windows\n\n// Windows backend based on ReadDirectoryChangesW()\n//\n// https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-readdirectorychangesw\n//\n// Note: the documentation on the Watcher type and methods is generated from\n// mkdoc.zsh\n\npackage fsnotify\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"reflect\"\n\t\"runtime\"\n\t\"strings\"\n\t\"sync\"\n\t\"unsafe\"\n\n\t\"golang.org/x/sys/windows\"\n)\n\n// Watcher watches a set of paths, delivering events on a channel.\n//\n// A watcher should not be copied (e.g. pass it by pointer, rather than by\n// value).\n//\n// # Linux notes\n//\n// When a file is removed a Remove event won't be emitted until all file\n// descriptors are closed, and deletes will always emit a Chmod. For example:\n//\n//\tfp := os.Open(\"file\")\n//\tos.Remove(\"file\") // Triggers Chmod\n//\tfp.Close() // Triggers Remove\n//\n// This is the event that inotify sends, so not much can be changed about this.\n//\n// The fs.inotify.max_user_watches sysctl variable specifies the upper limit\n// for the number of watches per user, and fs.inotify.max_user_instances\n// specifies the maximum number of inotify instances per user. Every Watcher you\n// create is an \"instance\", and every path you add is a \"watch\".\n//\n// These are also exposed in /proc as /proc/sys/fs/inotify/max_user_watches and\n// /proc/sys/fs/inotify/max_user_instances\n//\n// To increase them you can use sysctl or write the value to the /proc file:\n//\n//\t# Default values on Linux 5.18\n//\tsysctl fs.inotify.max_user_watches=124983\n//\tsysctl fs.inotify.max_user_instances=128\n//\n// To make the changes persist on reboot edit /etc/sysctl.conf or\n// /usr/lib/sysctl.d/50-default.conf (details differ per Linux distro; check\n// your distro's documentation):\n//\n//\tfs.inotify.max_user_watches=124983\n//\tfs.inotify.max_user_instances=128\n//\n// Reaching the limit will result in a \"no space left on device\" or \"too many open\n// files\" error.\n//\n// # kqueue notes (macOS, BSD)\n//\n// kqueue requires opening a file descriptor for every file that's being watched;\n// so if you're watching a directory with five files then that's six file\n// descriptors. You will run in to your system's \"max open files\" limit faster on\n// these platforms.\n//\n// The sysctl variables kern.maxfiles and kern.maxfilesperproc can be used to\n// control the maximum number of open files, as well as /etc/login.conf on BSD\n// systems.\n//\n// # Windows notes\n//\n// Paths can be added as \"C:\\path\\to\\dir\", but forward slashes\n// (\"C:/path/to/dir\") will also work.\n//\n// When a watched directory is removed it will always send an event for the\n// directory itself, but may not send events for all files in that directory.\n// Sometimes it will send events for all times, sometimes it will send no\n// events, and often only for some files.\n//\n// The default ReadDirectoryChangesW() buffer size is 64K, which is the largest\n// value that is guaranteed to work with SMB filesystems. If you have many\n// events in quick succession this may not be enough, and you will have to use\n// [WithBufferSize] to increase the value.\ntype Watcher struct {\n\t// Events sends the filesystem change events.\n\t//\n\t// fsnotify can send the following events; a \"path\" here can refer to a\n\t// file, directory, symbolic link, or special file like a FIFO.\n\t//\n\t// fsnotify.Create A new path was created; this may be followed by one\n\t// or more Write events if data also gets written to a\n\t// file.\n\t//\n\t// fsnotify.Remove A path was removed.\n\t//\n\t// fsnotify.Rename A path was renamed. A rename is always sent with the\n\t// old path as Event.Name, and a Create event will be\n\t// sent with the new name. Renames are only sent for\n\t// paths that are currently watched; e.g. moving an\n\t// unmonitored file into a monitored directory will\n\t// show up as just a Create. Similarly, renaming a file\n\t// to outside a monitored directory will show up as\n\t// only a Rename.\n\t//\n\t// fsnotify.Write A file or named pipe was written to. A Truncate will\n\t// also trigger a Write. A single \"write action\"\n\t// initiated by the user may show up as one or multiple\n\t// writes, depending on when the system syncs things to\n\t// disk. For example when compiling a large Go program\n\t// you may get hundreds of Write events, and you may\n\t// want to wait until you've stopped receiving them\n\t// (see the dedup example in cmd/fsnotify).\n\t//\n\t// Some systems may send Write event for directories\n\t// when the directory content changes.\n\t//\n\t// fsnotify.Chmod Attributes were changed. On Linux this is also sent\n\t// when a file is removed (or more accurately, when a\n\t// link to an inode is removed). On kqueue it's sent\n\t// when a file is truncated. On Windows it's never\n\t// sent.\n\tEvents chan Event\n\n\t// Errors sends any errors.\n\t//\n\t// ErrEventOverflow is used to indicate there are too many events:\n\t//\n\t// - inotify: There are too many queued events (fs.inotify.max_queued_events sysctl)\n\t// - windows: The buffer size is too small; WithBufferSize() can be used to increase it.\n\t// - kqueue, fen: Not used.\n\tErrors chan error\n\n\tport windows.Handle // Handle to completion port\n\tinput chan *input // Inputs to the reader are sent on this channel\n\tquit chan chan<- error\n\n\tmu sync.Mutex // Protects access to watches, closed\n\twatches watchMap // Map of watches (key: i-number)\n\tclosed bool // Set to true when Close() is first called\n}\n\n// NewWatcher creates a new Watcher.\nfunc NewWatcher() (*Watcher, error) {\n\treturn NewBufferedWatcher(50)\n}\n\n// NewBufferedWatcher creates a new Watcher with a buffered Watcher.Events\n// channel.\n//\n// The main use case for this is situations with a very large number of events\n// where the kernel buffer size can't be increased (e.g. due to lack of\n// permissions). An unbuffered Watcher will perform better for almost all use\n// cases, and whenever possible you will be better off increasing the kernel\n// buffers instead of adding a large userspace buffer.\nfunc NewBufferedWatcher(sz uint) (*Watcher, error) {\n\tport, err := windows.CreateIoCompletionPort(windows.InvalidHandle, 0, 0, 0)\n\tif err != nil {\n\t\treturn nil, os.NewSyscallError(\"CreateIoCompletionPort\", err)\n\t}\n\tw := &Watcher{\n\t\tport: port,\n\t\twatches: make(watchMap),\n\t\tinput: make(chan *input, 1),\n\t\tEvents: make(chan Event, sz),\n\t\tErrors: make(chan error),\n\t\tquit: make(chan chan<- error, 1),\n\t}\n\tgo w.readEvents()\n\treturn w, nil\n}\n\nfunc (w *Watcher) isClosed() bool {\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\treturn w.closed\n}\n\nfunc (w *Watcher) sendEvent(name string, mask uint64) bool {\n\tif mask == 0 {\n\t\treturn false\n\t}\n\n\tevent := w.newEvent(name, uint32(mask))\n\tselect {\n\tcase ch := <-w.quit:\n\t\tw.quit <- ch\n\tcase w.Events <- event:\n\t}\n\treturn true\n}\n\n// Returns true if the error was sent, or false if watcher is closed.\nfunc (w *Watcher) sendError(err error) bool {\n\tselect {\n\tcase w.Errors <- err:\n\t\treturn true\n\tcase <-w.quit:\n\t}\n\treturn false\n}\n\n// Close removes all watches and closes the Events channel.\nfunc (w *Watcher) Close() error {\n\tif w.isClosed() {\n\t\treturn nil\n\t}\n\n\tw.mu.Lock()\n\tw.closed = true\n\tw.mu.Unlock()\n\n\t// Send \"quit\" message to the reader goroutine\n\tch := make(chan error)\n\tw.quit <- ch\n\tif err := w.wakeupReader(); err != nil {\n\t\treturn err\n\t}\n\treturn <-ch\n}\n\n// Add starts monitoring the path for changes.\n//\n// A path can only be watched once; watching it more than once is a no-op and will\n// not return an error. Paths that do not yet exist on the filesystem cannot be\n// watched.\n//\n// A watch will be automatically removed if the watched path is deleted or\n// renamed. The exception is the Windows backend, which doesn't remove the\n// watcher on renames.\n//\n// Notifications on network filesystems (NFS, SMB, FUSE, etc.) or special\n// filesystems (/proc, /sys, etc.) generally don't work.\n//\n// Returns [ErrClosed] if [Watcher.Close] was called.\n//\n// See [Watcher.AddWith] for a version that allows adding options.\n//\n// # Watching directories\n//\n// All files in a directory are monitored, including new files that are created\n// after the watcher is started. Subdirectories are not watched (i.e. it's\n// non-recursive).\n//\n// # Watching files\n//\n// Watching individual files (rather than directories) is generally not\n// recommended as many programs (especially editors) update files atomically: it\n// will write to a temporary file which is then moved to to destination,\n// overwriting the original (or some variant thereof). The watcher on the\n// original file is now lost, as that no longer exists.\n//\n// The upshot of this is that a power failure or crash won't leave a\n// half-written file.\n//\n// Watch the parent directory and use Event.Name to filter out files you're not\n// interested in. There is an example of this in cmd/fsnotify/file.go.\nfunc (w *Watcher) Add(name string) error { return w.AddWith(name) }\n\n// AddWith is like [Watcher.Add], but allows adding options. When using Add()\n// the defaults described below are used.\n//\n// Possible options are:\n//\n// - [WithBufferSize] sets the buffer size for the Windows backend; no-op on\n// other platforms. The default is 64K (65536 bytes).\nfunc (w *Watcher) AddWith(name string, opts ...addOpt) error {\n\tif w.isClosed() {\n\t\treturn ErrClosed\n\t}\n\n\twith := getOptions(opts...)\n\tif with.bufsize < 4096 {\n\t\treturn fmt.Errorf(\"fsnotify.WithBufferSize: buffer size cannot be smaller than 4096 bytes\")\n\t}\n\n\tin := &input{\n\t\top: opAddWatch,\n\t\tpath: filepath.Clean(name),\n\t\tflags: sysFSALLEVENTS,\n\t\treply: make(chan error),\n\t\tbufsize: with.bufsize,\n\t}\n\tw.input <- in\n\tif err := w.wakeupReader(); err != nil {\n\t\treturn err\n\t}\n\treturn <-in.reply\n}\n\n// Remove stops monitoring the path for changes.\n//\n// Directories are always removed non-recursively. For example, if you added\n// /tmp/dir and /tmp/dir/subdir then you will need to remove both.\n//\n// Removing a path that has not yet been added returns [ErrNonExistentWatch].\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) Remove(name string) error {\n\tif w.isClosed() {\n\t\treturn nil\n\t}\n\n\tin := &input{\n\t\top: opRemoveWatch,\n\t\tpath: filepath.Clean(name),\n\t\treply: make(chan error),\n\t}\n\tw.input <- in\n\tif err := w.wakeupReader(); err != nil {\n\t\treturn err\n\t}\n\treturn <-in.reply\n}\n\n// WatchList returns all paths explicitly added with [Watcher.Add] (and are not\n// yet removed).\n//\n// Returns nil if [Watcher.Close] was called.\nfunc (w *Watcher) WatchList() []string {\n\tif w.isClosed() {\n\t\treturn nil\n\t}\n\n\tw.mu.Lock()\n\tdefer w.mu.Unlock()\n\n\tentries := make([]string, 0, len(w.watches))\n\tfor _, entry := range w.watches {\n\t\tfor _, watchEntry := range entry {\n\t\t\tentries = append(entries, watchEntry.path)\n\t\t}\n\t}\n\n\treturn entries\n}\n\n// These options are from the old golang.org/x/exp/winfsnotify, where you could\n// add various options to the watch. This has long since been removed.\n//\n// The \"sys\" in the name is misleading as they're not part of any \"system\".\n//\n// This should all be removed at some point, and just use windows.FILE_NOTIFY_*\nconst (\n\tsysFSALLEVENTS = 0xfff\n\tsysFSCREATE = 0x100\n\tsysFSDELETE = 0x200\n\tsysFSDELETESELF = 0x400\n\tsysFSMODIFY = 0x2\n\tsysFSMOVE = 0xc0\n\tsysFSMOVEDFROM = 0x40\n\tsysFSMOVEDTO = 0x80\n\tsysFSMOVESELF = 0x800\n\tsysFSIGNORED = 0x8000\n)\n\nfunc (w *Watcher) newEvent(name string, mask uint32) Event {\n\te := Event{Name: name}\n\tif mask&sysFSCREATE == sysFSCREATE || mask&sysFSMOVEDTO == sysFSMOVEDTO {\n\t\te.Op |= Create\n\t}\n\tif mask&sysFSDELETE == sysFSDELETE || mask&sysFSDELETESELF == sysFSDELETESELF {\n\t\te.Op |= Remove\n\t}\n\tif mask&sysFSMODIFY == sysFSMODIFY {\n\t\te.Op |= Write\n\t}\n\tif mask&sysFSMOVE == sysFSMOVE || mask&sysFSMOVESELF == sysFSMOVESELF || mask&sysFSMOVEDFROM == sysFSMOVEDFROM {\n\t\te.Op |= Rename\n\t}\n\treturn e\n}\n\nconst (\n\topAddWatch = iota\n\topRemoveWatch\n)\n\nconst (\n\tprovisional uint64 = 1 << (32 + iota)\n)\n\ntype input struct {\n\top int\n\tpath string\n\tflags uint32\n\tbufsize int\n\treply chan error\n}\n\ntype inode struct {\n\thandle windows.Handle\n\tvolume uint32\n\tindex uint64\n}\n\ntype watch struct {\n\tov windows.Overlapped\n\tino *inode // i-number\n\trecurse bool // Recursive watch?\n\tpath string // Directory path\n\tmask uint64 // Directory itself is being watched with these notify flags\n\tnames map[string]uint64 // Map of names being watched and their notify flags\n\trename string // Remembers the old name while renaming a file\n\tbuf []byte // buffer, allocated later\n}\n\ntype (\n\tindexMap map[uint64]*watch\n\twatchMap map[uint32]indexMap\n)\n\nfunc (w *Watcher) wakeupReader() error {\n\terr := windows.PostQueuedCompletionStatus(w.port, 0, 0, nil)\n\tif err != nil {\n\t\treturn os.NewSyscallError(\"PostQueuedCompletionStatus\", err)\n\t}\n\treturn nil\n}\n\nfunc (w *Watcher) getDir(pathname string) (dir string, err error) {\n\tattr, err := windows.GetFileAttributes(windows.StringToUTF16Ptr(pathname))\n\tif err != nil {\n\t\treturn \"\", os.NewSyscallError(\"GetFileAttributes\", err)\n\t}\n\tif attr&windows.FILE_ATTRIBUTE_DIRECTORY != 0 {\n\t\tdir = pathname\n\t} else {\n\t\tdir, _ = filepath.Split(pathname)\n\t\tdir = filepath.Clean(dir)\n\t}\n\treturn\n}\n\nfunc (w *Watcher) getIno(path string) (ino *inode, err error) {\n\th, err := windows.CreateFile(windows.StringToUTF16Ptr(path),\n\t\twindows.FILE_LIST_DIRECTORY,\n\t\twindows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE|windows.FILE_SHARE_DELETE,\n\t\tnil, windows.OPEN_EXISTING,\n\t\twindows.FILE_FLAG_BACKUP_SEMANTICS|windows.FILE_FLAG_OVERLAPPED, 0)\n\tif err != nil {\n\t\treturn nil, os.NewSyscallError(\"CreateFile\", err)\n\t}\n\n\tvar fi windows.ByHandleFileInformation\n\terr = windows.GetFileInformationByHandle(h, &fi)\n\tif err != nil {\n\t\twindows.CloseHandle(h)\n\t\treturn nil, os.NewSyscallError(\"GetFileInformationByHandle\", err)\n\t}\n\tino = &inode{\n\t\thandle: h,\n\t\tvolume: fi.VolumeSerialNumber,\n\t\tindex: uint64(fi.FileIndexHigh)<<32 | uint64(fi.FileIndexLow),\n\t}\n\treturn ino, nil\n}\n\n// Must run within the I/O thread.\nfunc (m watchMap) get(ino *inode) *watch {\n\tif i := m[ino.volume]; i != nil {\n\t\treturn i[ino.index]\n\t}\n\treturn nil\n}\n\n// Must run within the I/O thread.\nfunc (m watchMap) set(ino *inode, watch *watch) {\n\ti := m[ino.volume]\n\tif i == nil {\n\t\ti = make(indexMap)\n\t\tm[ino.volume] = i\n\t}\n\ti[ino.index] = watch\n}\n\n// Must run within the I/O thread.\nfunc (w *Watcher) addWatch(pathname string, flags uint64, bufsize int) error {\n\t//pathname, recurse := recursivePath(pathname)\n\trecurse := false\n\n\tdir, err := w.getDir(pathname)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tino, err := w.getIno(dir)\n\tif err != nil {\n\t\treturn err\n\t}\n\tw.mu.Lock()\n\twatchEntry := w.watches.get(ino)\n\tw.mu.Unlock()\n\tif watchEntry == nil {\n\t\t_, err := windows.CreateIoCompletionPort(ino.handle, w.port, 0, 0)\n\t\tif err != nil {\n\t\t\twindows.CloseHandle(ino.handle)\n\t\t\treturn os.NewSyscallError(\"CreateIoCompletionPort\", err)\n\t\t}\n\t\twatchEntry = &watch{\n\t\t\tino: ino,\n\t\t\tpath: dir,\n\t\t\tnames: make(map[string]uint64),\n\t\t\trecurse: recurse,\n\t\t\tbuf: make([]byte, bufsize),\n\t\t}\n\t\tw.mu.Lock()\n\t\tw.watches.set(ino, watchEntry)\n\t\tw.mu.Unlock()\n\t\tflags |= provisional\n\t} else {\n\t\twindows.CloseHandle(ino.handle)\n\t}\n\tif pathname == dir {\n\t\twatchEntry.mask |= flags\n\t} else {\n\t\twatchEntry.names[filepath.Base(pathname)] |= flags\n\t}\n\n\terr = w.startRead(watchEntry)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tif pathname == dir {\n\t\twatchEntry.mask &= ^provisional\n\t} else {\n\t\twatchEntry.names[filepath.Base(pathname)] &= ^provisional\n\t}\n\treturn nil\n}\n\n// Must run within the I/O thread.\nfunc (w *Watcher) remWatch(pathname string) error {\n\tpathname, recurse := recursivePath(pathname)\n\n\tdir, err := w.getDir(pathname)\n\tif err != nil {\n\t\treturn err\n\t}\n\tino, err := w.getIno(dir)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\tw.mu.Lock()\n\twatch := w.watches.get(ino)\n\tw.mu.Unlock()\n\n\tif recurse && !watch.recurse {\n\t\treturn fmt.Errorf(\"can't use \\\\... with non-recursive watch %q\", pathname)\n\t}\n\n\terr = windows.CloseHandle(ino.handle)\n\tif err != nil {\n\t\tw.sendError(os.NewSyscallError(\"CloseHandle\", err))\n\t}\n\tif watch == nil {\n\t\treturn fmt.Errorf(\"%w: %s\", ErrNonExistentWatch, pathname)\n\t}\n\tif pathname == dir {\n\t\tw.sendEvent(watch.path, watch.mask&sysFSIGNORED)\n\t\twatch.mask = 0\n\t} else {\n\t\tname := filepath.Base(pathname)\n\t\tw.sendEvent(filepath.Join(watch.path, name), watch.names[name]&sysFSIGNORED)\n\t\tdelete(watch.names, name)\n\t}\n\n\treturn w.startRead(watch)\n}\n\n// Must run within the I/O thread.\nfunc (w *Watcher) deleteWatch(watch *watch) {\n\tfor name, mask := range watch.names {\n\t\tif mask&provisional == 0 {\n\t\t\tw.sendEvent(filepath.Join(watch.path, name), mask&sysFSIGNORED)\n\t\t}\n\t\tdelete(watch.names, name)\n\t}\n\tif watch.mask != 0 {\n\t\tif watch.mask&provisional == 0 {\n\t\t\tw.sendEvent(watch.path, watch.mask&sysFSIGNORED)\n\t\t}\n\t\twatch.mask = 0\n\t}\n}\n\n// Must run within the I/O thread.\nfunc (w *Watcher) startRead(watch *watch) error {\n\terr := windows.CancelIo(watch.ino.handle)\n\tif err != nil {\n\t\tw.sendError(os.NewSyscallError(\"CancelIo\", err))\n\t\tw.deleteWatch(watch)\n\t}\n\tmask := w.toWindowsFlags(watch.mask)\n\tfor _, m := range watch.names {\n\t\tmask |= w.toWindowsFlags(m)\n\t}\n\tif mask == 0 {\n\t\terr := windows.CloseHandle(watch.ino.handle)\n\t\tif err != nil {\n\t\t\tw.sendError(os.NewSyscallError(\"CloseHandle\", err))\n\t\t}\n\t\tw.mu.Lock()\n\t\tdelete(w.watches[watch.ino.volume], watch.ino.index)\n\t\tw.mu.Unlock()\n\t\treturn nil\n\t}\n\n\t// We need to pass the array, rather than the slice.\n\thdr := (*reflect.SliceHeader)(unsafe.Pointer(&watch.buf))\n\trdErr := windows.ReadDirectoryChanges(watch.ino.handle,\n\t\t(*byte)(unsafe.Pointer(hdr.Data)), uint32(hdr.Len),\n\t\twatch.recurse, mask, nil, &watch.ov, 0)\n\tif rdErr != nil {\n\t\terr := os.NewSyscallError(\"ReadDirectoryChanges\", rdErr)\n\t\tif rdErr == windows.ERROR_ACCESS_DENIED && watch.mask&provisional == 0 {\n\t\t\t// Watched directory was probably removed\n\t\t\tw.sendEvent(watch.path, watch.mask&sysFSDELETESELF)\n\t\t\terr = nil\n\t\t}\n\t\tw.deleteWatch(watch)\n\t\tw.startRead(watch)\n\t\treturn err\n\t}\n\treturn nil\n}\n\n// readEvents reads from the I/O completion port, converts the\n// received events into Event objects and sends them via the Events channel.\n// Entry point to the I/O thread.\nfunc (w *Watcher) readEvents() {\n\tvar (\n\t\tn uint32\n\t\tkey uintptr\n\t\tov *windows.Overlapped\n\t)\n\truntime.LockOSThread()\n\n\tfor {\n\t\t// This error is handled after the watch == nil check below.\n\t\tqErr := windows.GetQueuedCompletionStatus(w.port, &n, &key, &ov, windows.INFINITE)\n\n\t\twatch := (*watch)(unsafe.Pointer(ov))\n\t\tif watch == nil {\n\t\t\tselect {\n\t\t\tcase ch := <-w.quit:\n\t\t\t\tw.mu.Lock()\n\t\t\t\tvar indexes []indexMap\n\t\t\t\tfor _, index := range w.watches {\n\t\t\t\t\tindexes = append(indexes, index)\n\t\t\t\t}\n\t\t\t\tw.mu.Unlock()\n\t\t\t\tfor _, index := range indexes {\n\t\t\t\t\tfor _, watch := range index {\n\t\t\t\t\t\tw.deleteWatch(watch)\n\t\t\t\t\t\tw.startRead(watch)\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\terr := windows.CloseHandle(w.port)\n\t\t\t\tif err != nil {\n\t\t\t\t\terr = os.NewSyscallError(\"CloseHandle\", err)\n\t\t\t\t}\n\t\t\t\tclose(w.Events)\n\t\t\t\tclose(w.Errors)\n\t\t\t\tch <- err\n\t\t\t\treturn\n\t\t\tcase in := <-w.input:\n\t\t\t\tswitch in.op {\n\t\t\t\tcase opAddWatch:\n\t\t\t\t\tin.reply <- w.addWatch(in.path, uint64(in.flags), in.bufsize)\n\t\t\t\tcase opRemoveWatch:\n\t\t\t\t\tin.reply <- w.remWatch(in.path)\n\t\t\t\t}\n\t\t\tdefault:\n\t\t\t}\n\t\t\tcontinue\n\t\t}\n\n\t\tswitch qErr {\n\t\tcase nil:\n\t\t\t// No error\n\t\tcase windows.ERROR_MORE_DATA:\n\t\t\tif watch == nil {\n\t\t\t\tw.sendError(errors.New(\"ERROR_MORE_DATA has unexpectedly null lpOverlapped buffer\"))\n\t\t\t} else {\n\t\t\t\t// The i/o succeeded but the buffer is full.\n\t\t\t\t// In theory we should be building up a full packet.\n\t\t\t\t// In practice we can get away with just carrying on.\n\t\t\t\tn = uint32(unsafe.Sizeof(watch.buf))\n\t\t\t}\n\t\tcase windows.ERROR_ACCESS_DENIED:\n\t\t\t// Watched directory was probably removed\n\t\t\tw.sendEvent(watch.path, watch.mask&sysFSDELETESELF)\n\t\t\tw.deleteWatch(watch)\n\t\t\tw.startRead(watch)\n\t\t\tcontinue\n\t\tcase windows.ERROR_OPERATION_ABORTED:\n\t\t\t// CancelIo was called on this handle\n\t\t\tcontinue\n\t\tdefault:\n\t\t\tw.sendError(os.NewSyscallError(\"GetQueuedCompletionPort\", qErr))\n\t\t\tcontinue\n\t\t}\n\n\t\tvar offset uint32\n\t\tfor {\n\t\t\tif n == 0 {\n\t\t\t\tw.sendError(ErrEventOverflow)\n\t\t\t\tbreak\n\t\t\t}\n\n\t\t\t// Point \"raw\" to the event in the buffer\n\t\t\traw := (*windows.FileNotifyInformation)(unsafe.Pointer(&watch.buf[offset]))\n\n\t\t\t// Create a buf that is the size of the path name\n\t\t\tsize := int(raw.FileNameLength / 2)\n\t\t\tvar buf []uint16\n\t\t\t// TODO: Use unsafe.Slice in Go 1.17; https://stackoverflow.com/questions/51187973\n\t\t\tsh := (*reflect.SliceHeader)(unsafe.Pointer(&buf))\n\t\t\tsh.Data = uintptr(unsafe.Pointer(&raw.FileName))\n\t\t\tsh.Len = size\n\t\t\tsh.Cap = size\n\t\t\tname := windows.UTF16ToString(buf)\n\t\t\tfullname := filepath.Join(watch.path, name)\n\n\t\t\tvar mask uint64\n\t\t\tswitch raw.Action {\n\t\t\tcase windows.FILE_ACTION_REMOVED:\n\t\t\t\tmask = sysFSDELETESELF\n\t\t\tcase windows.FILE_ACTION_MODIFIED:\n\t\t\t\tmask = sysFSMODIFY\n\t\t\tcase windows.FILE_ACTION_RENAMED_OLD_NAME:\n\t\t\t\twatch.rename = name\n\t\t\tcase windows.FILE_ACTION_RENAMED_NEW_NAME:\n\t\t\t\t// Update saved path of all sub-watches.\n\t\t\t\told := filepath.Join(watch.path, watch.rename)\n\t\t\t\tw.mu.Lock()\n\t\t\t\tfor _, watchMap := range w.watches {\n\t\t\t\t\tfor _, ww := range watchMap {\n\t\t\t\t\t\tif strings.HasPrefix(ww.path, old) {\n\t\t\t\t\t\t\tww.path = filepath.Join(fullname, strings.TrimPrefix(ww.path, old))\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tw.mu.Unlock()\n\n\t\t\t\tif watch.names[watch.rename] != 0 {\n\t\t\t\t\twatch.names[name] |= watch.names[watch.rename]\n\t\t\t\t\tdelete(watch.names, watch.rename)\n\t\t\t\t\tmask = sysFSMOVESELF\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tsendNameEvent := func() {\n\t\t\t\tw.sendEvent(fullname, watch.names[name]&mask)\n\t\t\t}\n\t\t\tif raw.Action != windows.FILE_ACTION_RENAMED_NEW_NAME {\n\t\t\t\tsendNameEvent()\n\t\t\t}\n\t\t\tif raw.Action == windows.FILE_ACTION_REMOVED {\n\t\t\t\tw.sendEvent(fullname, watch.names[name]&sysFSIGNORED)\n\t\t\t\tdelete(watch.names, name)\n\t\t\t}\n\n\t\t\tw.sendEvent(fullname, watch.mask&w.toFSnotifyFlags(raw.Action))\n\t\t\tif raw.Action == windows.FILE_ACTION_RENAMED_NEW_NAME {\n\t\t\t\tfullname = filepath.Join(watch.path, watch.rename)\n\t\t\t\tsendNameEvent()\n\t\t\t}\n\n\t\t\t// Move to the next event in the buffer\n\t\t\tif raw.NextEntryOffset == 0 {\n\t\t\t\tbreak\n\t\t\t}\n\t\t\toffset += raw.NextEntryOffset\n\n\t\t\t// Error!\n\t\t\tif offset >= n {\n\t\t\t\t//lint:ignore ST1005 Windows should be capitalized\n\t\t\t\tw.sendError(errors.New(\n\t\t\t\t\t\"Windows system assumed buffer larger than it is, events have likely been missed\"))\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\n\t\tif err := w.startRead(watch); err != nil {\n\t\t\tw.sendError(err)\n\t\t}\n\t}\n}\n\nfunc (w *Watcher) toWindowsFlags(mask uint64) uint32 {\n\tvar m uint32\n\tif mask&sysFSMODIFY != 0 {\n\t\tm |= windows.FILE_NOTIFY_CHANGE_LAST_WRITE\n\t}\n\tif mask&(sysFSMOVE|sysFSCREATE|sysFSDELETE) != 0 {\n\t\tm |= windows.FILE_NOTIFY_CHANGE_FILE_NAME | windows.FILE_NOTIFY_CHANGE_DIR_NAME\n\t}\n\treturn m\n}\n\nfunc (w *Watcher) toFSnotifyFlags(action uint32) uint64 {\n\tswitch action {\n\tcase windows.FILE_ACTION_ADDED:\n\t\treturn sysFSCREATE\n\tcase windows.FILE_ACTION_REMOVED:\n\t\treturn sysFSDELETE\n\tcase windows.FILE_ACTION_MODIFIED:\n\t\treturn sysFSMODIFY\n\tcase windows.FILE_ACTION_RENAMED_OLD_NAME:\n\t\treturn sysFSMOVEDFROM\n\tcase windows.FILE_ACTION_RENAMED_NEW_NAME:\n\t\treturn sysFSMOVEDTO\n\t}\n\treturn 0\n}\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/fsnotify.go",
"content": "// Package fsnotify provides a cross-platform interface for file system\n// notifications.\n//\n// Currently supported systems:\n//\n//\tLinux 2.6.32+ via inotify\n//\tBSD, macOS via kqueue\n//\tWindows via ReadDirectoryChangesW\n//\tillumos via FEN\npackage fsnotify\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"path/filepath\"\n\t\"strings\"\n)\n\n// Event represents a file system notification.\ntype Event struct {\n\t// Path to the file or directory.\n\t//\n\t// Paths are relative to the input; for example with Add(\"dir\") the Name\n\t// will be set to \"dir/file\" if you create that file, but if you use\n\t// Add(\"/path/to/dir\") it will be \"/path/to/dir/file\".\n\tName string\n\n\t// File operation that triggered the event.\n\t//\n\t// This is a bitmask and some systems may send multiple operations at once.\n\t// Use the Event.Has() method instead of comparing with ==.\n\tOp Op\n}\n\n// Op describes a set of file operations.\ntype Op uint32\n\n// The operations fsnotify can trigger; see the documentation on [Watcher] for a\n// full description, and check them with [Event.Has].\nconst (\n\t// A new pathname was created.\n\tCreate Op = 1 << iota\n\n\t// The pathname was written to; this does *not* mean the write has finished,\n\t// and a write can be followed by more writes.\n\tWrite\n\n\t// The path was removed; any watches on it will be removed. Some \"remove\"\n\t// operations may trigger a Rename if the file is actually moved (for\n\t// example \"remove to trash\" is often a rename).\n\tRemove\n\n\t// The path was renamed to something else; any watched on it will be\n\t// removed.\n\tRename\n\n\t// File attributes were changed.\n\t//\n\t// It's generally not recommended to take action on this event, as it may\n\t// get triggered very frequently by some software. For example, Spotlight\n\t// indexing on macOS, anti-virus software, backup software, etc.\n\tChmod\n)\n\n// Common errors that can be reported.\nvar (\n\tErrNonExistentWatch = errors.New(\"fsnotify: can't remove non-existent watch\")\n\tErrEventOverflow = errors.New(\"fsnotify: queue or buffer overflow\")\n\tErrClosed = errors.New(\"fsnotify: watcher already closed\")\n)\n\nfunc (o Op) String() string {\n\tvar b strings.Builder\n\tif o.Has(Create) {\n\t\tb.WriteString(\"|CREATE\")\n\t}\n\tif o.Has(Remove) {\n\t\tb.WriteString(\"|REMOVE\")\n\t}\n\tif o.Has(Write) {\n\t\tb.WriteString(\"|WRITE\")\n\t}\n\tif o.Has(Rename) {\n\t\tb.WriteString(\"|RENAME\")\n\t}\n\tif o.Has(Chmod) {\n\t\tb.WriteString(\"|CHMOD\")\n\t}\n\tif b.Len() == 0 {\n\t\treturn \"[no events]\"\n\t}\n\treturn b.String()[1:]\n}\n\n// Has reports if this operation has the given operation.\nfunc (o Op) Has(h Op) bool { return o&h != 0 }\n\n// Has reports if this event has the given operation.\nfunc (e Event) Has(op Op) bool { return e.Op.Has(op) }\n\n// String returns a string representation of the event with their path.\nfunc (e Event) String() string {\n\treturn fmt.Sprintf(\"%-13s %q\", e.Op.String(), e.Name)\n}\n\ntype (\n\taddOpt func(opt *withOpts)\n\twithOpts struct {\n\t\tbufsize int\n\t}\n)\n\nvar defaultOpts = withOpts{\n\tbufsize: 65536, // 64K\n}\n\nfunc getOptions(opts ...addOpt) withOpts {\n\twith := defaultOpts\n\tfor _, o := range opts {\n\t\to(&with)\n\t}\n\treturn with\n}\n\n// WithBufferSize sets the [ReadDirectoryChangesW] buffer size.\n//\n// This only has effect on Windows systems, and is a no-op for other backends.\n//\n// The default value is 64K (65536 bytes) which is the highest value that works\n// on all filesystems and should be enough for most applications, but if you\n// have a large burst of events it may not be enough. You can increase it if\n// you're hitting \"queue or buffer overflow\" errors ([ErrEventOverflow]).\n//\n// [ReadDirectoryChangesW]: https://learn.microsoft.com/en-gb/windows/win32/api/winbase/nf-winbase-readdirectorychangesw\nfunc WithBufferSize(bytes int) addOpt {\n\treturn func(opt *withOpts) { opt.bufsize = bytes }\n}\n\n// Check if this path is recursive (ends with \"/...\" or \"\\...\"), and return the\n// path with the /... stripped.\nfunc recursivePath(path string) (string, bool) {\n\tif filepath.Base(path) == \"...\" {\n\t\treturn filepath.Dir(path), true\n\t}\n\treturn path, false\n}\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/mkdoc.zsh",
"content": "#!/usr/bin/env zsh\n[ \"${ZSH_VERSION:-}\" = \"\" ] && echo >&2 \"Only works with zsh\" && exit 1\nsetopt err_exit no_unset pipefail extended_glob\n\n# Simple script to update the godoc comments on all watchers so you don't need\n# to update the same comment 5 times.\n\nwatcher=$(</tmp/x\n\t\tprint -r -- $cmt >>/tmp/x\n\t\ttail -n+$(( end + 1 )) $file >>/tmp/x\n\t\tmv /tmp/x $file\n\tdone\n}\n\nset-cmt '^type Watcher struct ' $watcher\nset-cmt '^func NewWatcher(' $new\nset-cmt '^func NewBufferedWatcher(' $newbuffered\nset-cmt '^func (w \\*Watcher) Add(' $add\nset-cmt '^func (w \\*Watcher) AddWith(' $addwith\nset-cmt '^func (w \\*Watcher) Remove(' $remove\nset-cmt '^func (w \\*Watcher) Close(' $close\nset-cmt '^func (w \\*Watcher) WatchList(' $watchlist\nset-cmt '^[[:space:]]*Events *chan Event$' $events\nset-cmt '^[[:space:]]*Errors *chan error$' $errors\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/system_bsd.go",
"content": "//go:build freebsd || openbsd || netbsd || dragonfly\n// +build freebsd openbsd netbsd dragonfly\n\npackage fsnotify\n\nimport \"golang.org/x/sys/unix\"\n\nconst openMode = unix.O_NONBLOCK | unix.O_RDONLY | unix.O_CLOEXEC\n"
},
{
"path": "vendor/github.com/fsnotify/fsnotify/system_darwin.go",
"content": "//go:build darwin\n// +build darwin\n\npackage fsnotify\n\nimport \"golang.org/x/sys/unix\"\n\n// note: this constant is not defined on BSD\nconst openMode = unix.O_EVTONLY | unix.O_CLOEXEC\n"
},
{
"path": "vendor/github.com/ghodss/yaml/.gitignore",
"content": "# OSX leaves these everywhere on SMB shares\n._*\n\n# Eclipse files\n.classpath\n.project\n.settings/**\n\n# Emacs save files\n*~\n\n# Vim-related files\n[._]*.s[a-w][a-z]\n[._]s[a-w][a-z]\n*.un~\nSession.vim\n.netrwhist\n\n# Go test binaries\n*.test\n"
},
{
"path": "vendor/github.com/ghodss/yaml/.travis.yml",
"content": "language: go\ngo:\n - 1.3\n - 1.4\nscript:\n - go test\n - go build\n"
},
{
"path": "vendor/github.com/ghodss/yaml/LICENSE",
"content": "The MIT License (MIT)\n\nCopyright (c) 2014 Sam Ghods\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n\nCopyright (c) 2012 The Go Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
},
{
"path": "vendor/github.com/ghodss/yaml/README.md",
"content": "# YAML marshaling and unmarshaling support for Go\n\n[](https://travis-ci.org/ghodss/yaml)\n\n## Introduction\n\nA wrapper around [go-yaml](https://github.com/go-yaml/yaml) designed to enable a better way of handling YAML when marshaling to and from structs.\n\nIn short, this library first converts YAML to JSON using go-yaml and then uses `json.Marshal` and `json.Unmarshal` to convert to or from the struct. This means that it effectively reuses the JSON struct tags as well as the custom JSON methods `MarshalJSON` and `UnmarshalJSON` unlike go-yaml. For a detailed overview of the rationale behind this method, [see this blog post](http://ghodss.com/2014/the-right-way-to-handle-yaml-in-golang/).\n\n## Compatibility\n\nThis package uses [go-yaml](https://github.com/go-yaml/yaml) and therefore supports [everything go-yaml supports](https://github.com/go-yaml/yaml#compatibility).\n\n## Caveats\n\n**Caveat #1:** When using `yaml.Marshal` and `yaml.Unmarshal`, binary data should NOT be preceded with the `!!binary` YAML tag. If you do, go-yaml will convert the binary data from base64 to native binary data, which is not compatible with JSON. You can still use binary in your YAML files though - just store them without the `!!binary` tag and decode the base64 in your code (e.g. in the custom JSON methods `MarshalJSON` and `UnmarshalJSON`). This also has the benefit that your YAML and your JSON binary data will be decoded exactly the same way. As an example:\n\n```\nBAD:\n\texampleKey: !!binary gIGC\n\nGOOD:\n\texampleKey: gIGC\n... and decode the base64 data in your code.\n```\n\n**Caveat #2:** When using `YAMLToJSON` directly, maps with keys that are maps will result in an error since this is not supported by JSON. This error will occur in `Unmarshal` as well since you can't unmarshal map keys anyways since struct fields can't be keys.\n\n## Installation and usage\n\nTo install, run:\n\n```\n$ go get github.com/ghodss/yaml\n```\n\nAnd import using:\n\n```\nimport \"github.com/ghodss/yaml\"\n```\n\nUsage is very similar to the JSON library:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ghodss/yaml\"\n)\n\ntype Person struct {\n\tName string `json:\"name\"` // Affects YAML field names too.\n\tAge int `json:\"age\"`\n}\n\nfunc main() {\n\t// Marshal a Person struct to YAML.\n\tp := Person{\"John\", 30}\n\ty, err := yaml.Marshal(p)\n\tif err != nil {\n\t\tfmt.Printf(\"err: %v\\n\", err)\n\t\treturn\n\t}\n\tfmt.Println(string(y))\n\t/* Output:\n\tage: 30\n\tname: John\n\t*/\n\n\t// Unmarshal the YAML back into a Person struct.\n\tvar p2 Person\n\terr = yaml.Unmarshal(y, &p2)\n\tif err != nil {\n\t\tfmt.Printf(\"err: %v\\n\", err)\n\t\treturn\n\t}\n\tfmt.Println(p2)\n\t/* Output:\n\t{John 30}\n\t*/\n}\n```\n\n`yaml.YAMLToJSON` and `yaml.JSONToYAML` methods are also available:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/ghodss/yaml\"\n)\n\nfunc main() {\n\tj := []byte(`{\"name\": \"John\", \"age\": 30}`)\n\ty, err := yaml.JSONToYAML(j)\n\tif err != nil {\n\t\tfmt.Printf(\"err: %v\\n\", err)\n\t\treturn\n\t}\n\tfmt.Println(string(y))\n\t/* Output:\n\tname: John\n\tage: 30\n\t*/\n\tj2, err := yaml.YAMLToJSON(y)\n\tif err != nil {\n\t\tfmt.Printf(\"err: %v\\n\", err)\n\t\treturn\n\t}\n\tfmt.Println(string(j2))\n\t/* Output:\n\t{\"age\":30,\"name\":\"John\"}\n\t*/\n}\n```\n"
},
{
"path": "vendor/github.com/ghodss/yaml/fields.go",
"content": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\npackage yaml\n\nimport (\n\t\"bytes\"\n\t\"encoding\"\n\t\"encoding/json\"\n\t\"reflect\"\n\t\"sort\"\n\t\"strings\"\n\t\"sync\"\n\t\"unicode\"\n\t\"unicode/utf8\"\n)\n\n// indirect walks down v allocating pointers as needed,\n// until it gets to a non-pointer.\n// if it encounters an Unmarshaler, indirect stops and returns that.\n// if decodingNull is true, indirect stops at the last pointer so it can be set to nil.\nfunc indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {\n\t// If v is a named type and is addressable,\n\t// start with its address, so that if the type has pointer methods,\n\t// we find them.\n\tif v.Kind() != reflect.Ptr && v.Type().Name() != \"\" && v.CanAddr() {\n\t\tv = v.Addr()\n\t}\n\tfor {\n\t\t// Load value from interface, but only if the result will be\n\t\t// usefully addressable.\n\t\tif v.Kind() == reflect.Interface && !v.IsNil() {\n\t\t\te := v.Elem()\n\t\t\tif e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {\n\t\t\t\tv = e\n\t\t\t\tcontinue\n\t\t\t}\n\t\t}\n\n\t\tif v.Kind() != reflect.Ptr {\n\t\t\tbreak\n\t\t}\n\n\t\tif v.Elem().Kind() != reflect.Ptr && decodingNull && v.CanSet() {\n\t\t\tbreak\n\t\t}\n\t\tif v.IsNil() {\n\t\t\tif v.CanSet() {\n\t\t\t\tv.Set(reflect.New(v.Type().Elem()))\n\t\t\t} else {\n\t\t\t\tv = reflect.New(v.Type().Elem())\n\t\t\t}\n\t\t}\n\t\tif v.Type().NumMethod() > 0 {\n\t\t\tif u, ok := v.Interface().(json.Unmarshaler); ok {\n\t\t\t\treturn u, nil, reflect.Value{}\n\t\t\t}\n\t\t\tif u, ok := v.Interface().(encoding.TextUnmarshaler); ok {\n\t\t\t\treturn nil, u, reflect.Value{}\n\t\t\t}\n\t\t}\n\t\tv = v.Elem()\n\t}\n\treturn nil, nil, v\n}\n\n// A field represents a single field found in a struct.\ntype field struct {\n\tname string\n\tnameBytes []byte // []byte(name)\n\tequalFold func(s, t []byte) bool // bytes.EqualFold or equivalent\n\n\ttag bool\n\tindex []int\n\ttyp reflect.Type\n\tomitEmpty bool\n\tquoted bool\n}\n\nfunc fillField(f field) field {\n\tf.nameBytes = []byte(f.name)\n\tf.equalFold = foldFunc(f.nameBytes)\n\treturn f\n}\n\n// byName sorts field by name, breaking ties with depth,\n// then breaking ties with \"name came from json tag\", then\n// breaking ties with index sequence.\ntype byName []field\n\nfunc (x byName) Len() int { return len(x) }\n\nfunc (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }\n\nfunc (x byName) Less(i, j int) bool {\n\tif x[i].name != x[j].name {\n\t\treturn x[i].name < x[j].name\n\t}\n\tif len(x[i].index) != len(x[j].index) {\n\t\treturn len(x[i].index) < len(x[j].index)\n\t}\n\tif x[i].tag != x[j].tag {\n\t\treturn x[i].tag\n\t}\n\treturn byIndex(x).Less(i, j)\n}\n\n// byIndex sorts field by index sequence.\ntype byIndex []field\n\nfunc (x byIndex) Len() int { return len(x) }\n\nfunc (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }\n\nfunc (x byIndex) Less(i, j int) bool {\n\tfor k, xik := range x[i].index {\n\t\tif k >= len(x[j].index) {\n\t\t\treturn false\n\t\t}\n\t\tif xik != x[j].index[k] {\n\t\t\treturn xik < x[j].index[k]\n\t\t}\n\t}\n\treturn len(x[i].index) < len(x[j].index)\n}\n\n// typeFields returns a list of fields that JSON should recognize for the given type.\n// The algorithm is breadth-first search over the set of structs to include - the top struct\n// and then any reachable anonymous structs.\nfunc typeFields(t reflect.Type) []field {\n\t// Anonymous fields to explore at the current level and the next.\n\tcurrent := []field{}\n\tnext := []field{{typ: t}}\n\n\t// Count of queued names for current level and the next.\n\tcount := map[reflect.Type]int{}\n\tnextCount := map[reflect.Type]int{}\n\n\t// Types already visited at an earlier level.\n\tvisited := map[reflect.Type]bool{}\n\n\t// Fields found.\n\tvar fields []field\n\n\tfor len(next) > 0 {\n\t\tcurrent, next = next, current[:0]\n\t\tcount, nextCount = nextCount, map[reflect.Type]int{}\n\n\t\tfor _, f := range current {\n\t\t\tif visited[f.typ] {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tvisited[f.typ] = true\n\n\t\t\t// Scan f.typ for fields to include.\n\t\t\tfor i := 0; i < f.typ.NumField(); i++ {\n\t\t\t\tsf := f.typ.Field(i)\n\t\t\t\tif sf.PkgPath != \"\" { // unexported\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\ttag := sf.Tag.Get(\"json\")\n\t\t\t\tif tag == \"-\" {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tname, opts := parseTag(tag)\n\t\t\t\tif !isValidTag(name) {\n\t\t\t\t\tname = \"\"\n\t\t\t\t}\n\t\t\t\tindex := make([]int, len(f.index)+1)\n\t\t\t\tcopy(index, f.index)\n\t\t\t\tindex[len(f.index)] = i\n\n\t\t\t\tft := sf.Type\n\t\t\t\tif ft.Name() == \"\" && ft.Kind() == reflect.Ptr {\n\t\t\t\t\t// Follow pointer.\n\t\t\t\t\tft = ft.Elem()\n\t\t\t\t}\n\n\t\t\t\t// Record found field and index sequence.\n\t\t\t\tif name != \"\" || !sf.Anonymous || ft.Kind() != reflect.Struct {\n\t\t\t\t\ttagged := name != \"\"\n\t\t\t\t\tif name == \"\" {\n\t\t\t\t\t\tname = sf.Name\n\t\t\t\t\t}\n\t\t\t\t\tfields = append(fields, fillField(field{\n\t\t\t\t\t\tname: name,\n\t\t\t\t\t\ttag: tagged,\n\t\t\t\t\t\tindex: index,\n\t\t\t\t\t\ttyp: ft,\n\t\t\t\t\t\tomitEmpty: opts.Contains(\"omitempty\"),\n\t\t\t\t\t\tquoted: opts.Contains(\"string\"),\n\t\t\t\t\t}))\n\t\t\t\t\tif count[f.typ] > 1 {\n\t\t\t\t\t\t// If there were multiple instances, add a second,\n\t\t\t\t\t\t// so that the annihilation code will see a duplicate.\n\t\t\t\t\t\t// It only cares about the distinction between 1 or 2,\n\t\t\t\t\t\t// so don't bother generating any more copies.\n\t\t\t\t\t\tfields = append(fields, fields[len(fields)-1])\n\t\t\t\t\t}\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\t// Record new anonymous struct to explore in next round.\n\t\t\t\tnextCount[ft]++\n\t\t\t\tif nextCount[ft] == 1 {\n\t\t\t\t\tnext = append(next, fillField(field{name: ft.Name(), index: index, typ: ft}))\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tsort.Sort(byName(fields))\n\n\t// Delete all fields that are hidden by the Go rules for embedded fields,\n\t// except that fields with JSON tags are promoted.\n\n\t// The fields are sorted in primary order of name, secondary order\n\t// of field index length. Loop over names; for each name, delete\n\t// hidden fields by choosing the one dominant field that survives.\n\tout := fields[:0]\n\tfor advance, i := 0, 0; i < len(fields); i += advance {\n\t\t// One iteration per name.\n\t\t// Find the sequence of fields with the name of this first field.\n\t\tfi := fields[i]\n\t\tname := fi.name\n\t\tfor advance = 1; i+advance < len(fields); advance++ {\n\t\t\tfj := fields[i+advance]\n\t\t\tif fj.name != name {\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\tif advance == 1 { // Only one field with this name\n\t\t\tout = append(out, fi)\n\t\t\tcontinue\n\t\t}\n\t\tdominant, ok := dominantField(fields[i : i+advance])\n\t\tif ok {\n\t\t\tout = append(out, dominant)\n\t\t}\n\t}\n\n\tfields = out\n\tsort.Sort(byIndex(fields))\n\n\treturn fields\n}\n\n// dominantField looks through the fields, all of which are known to\n// have the same name, to find the single field that dominates the\n// others using Go's embedding rules, modified by the presence of\n// JSON tags. If there are multiple top-level fields, the boolean\n// will be false: This condition is an error in Go and we skip all\n// the fields.\nfunc dominantField(fields []field) (field, bool) {\n\t// The fields are sorted in increasing index-length order. The winner\n\t// must therefore be one with the shortest index length. Drop all\n\t// longer entries, which is easy: just truncate the slice.\n\tlength := len(fields[0].index)\n\ttagged := -1 // Index of first tagged field.\n\tfor i, f := range fields {\n\t\tif len(f.index) > length {\n\t\t\tfields = fields[:i]\n\t\t\tbreak\n\t\t}\n\t\tif f.tag {\n\t\t\tif tagged >= 0 {\n\t\t\t\t// Multiple tagged fields at the same level: conflict.\n\t\t\t\t// Return no field.\n\t\t\t\treturn field{}, false\n\t\t\t}\n\t\t\ttagged = i\n\t\t}\n\t}\n\tif tagged >= 0 {\n\t\treturn fields[tagged], true\n\t}\n\t// All remaining fields have the same length. If there's more than one,\n\t// we have a conflict (two fields named \"X\" at the same level) and we\n\t// return no field.\n\tif len(fields) > 1 {\n\t\treturn field{}, false\n\t}\n\treturn fields[0], true\n}\n\nvar fieldCache struct {\n\tsync.RWMutex\n\tm map[reflect.Type][]field\n}\n\n// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.\nfunc cachedTypeFields(t reflect.Type) []field {\n\tfieldCache.RLock()\n\tf := fieldCache.m[t]\n\tfieldCache.RUnlock()\n\tif f != nil {\n\t\treturn f\n\t}\n\n\t// Compute fields without lock.\n\t// Might duplicate effort but won't hold other computations back.\n\tf = typeFields(t)\n\tif f == nil {\n\t\tf = []field{}\n\t}\n\n\tfieldCache.Lock()\n\tif fieldCache.m == nil {\n\t\tfieldCache.m = map[reflect.Type][]field{}\n\t}\n\tfieldCache.m[t] = f\n\tfieldCache.Unlock()\n\treturn f\n}\n\nfunc isValidTag(s string) bool {\n\tif s == \"\" {\n\t\treturn false\n\t}\n\tfor _, c := range s {\n\t\tswitch {\n\t\tcase strings.ContainsRune(\"!#$%&()*+-./:<=>?@[]^_{|}~ \", c):\n\t\t\t// Backslash and quote chars are reserved, but\n\t\t\t// otherwise any punctuation chars are allowed\n\t\t\t// in a tag name.\n\t\tdefault:\n\t\t\tif !unicode.IsLetter(c) && !unicode.IsDigit(c) {\n\t\t\t\treturn false\n\t\t\t}\n\t\t}\n\t}\n\treturn true\n}\n\nconst (\n\tcaseMask = ^byte(0x20) // Mask to ignore case in ASCII.\n\tkelvin = '\\u212a'\n\tsmallLongEss = '\\u017f'\n)\n\n// foldFunc returns one of four different case folding equivalence\n// functions, from most general (and slow) to fastest:\n//\n// 1) bytes.EqualFold, if the key s contains any non-ASCII UTF-8\n// 2) equalFoldRight, if s contains special folding ASCII ('k', 'K', 's', 'S')\n// 3) asciiEqualFold, no special, but includes non-letters (including _)\n// 4) simpleLetterEqualFold, no specials, no non-letters.\n//\n// The letters S and K are special because they map to 3 runes, not just 2:\n// * S maps to s and to U+017F 'ſ' Latin small letter long s\n// * k maps to K and to U+212A 'K' Kelvin sign\n// See http://play.golang.org/p/tTxjOc0OGo\n//\n// The returned function is specialized for matching against s and\n// should only be given s. It's not curried for performance reasons.\nfunc foldFunc(s []byte) func(s, t []byte) bool {\n\tnonLetter := false\n\tspecial := false // special letter\n\tfor _, b := range s {\n\t\tif b >= utf8.RuneSelf {\n\t\t\treturn bytes.EqualFold\n\t\t}\n\t\tupper := b & caseMask\n\t\tif upper < 'A' || upper > 'Z' {\n\t\t\tnonLetter = true\n\t\t} else if upper == 'K' || upper == 'S' {\n\t\t\t// See above for why these letters are special.\n\t\t\tspecial = true\n\t\t}\n\t}\n\tif special {\n\t\treturn equalFoldRight\n\t}\n\tif nonLetter {\n\t\treturn asciiEqualFold\n\t}\n\treturn simpleLetterEqualFold\n}\n\n// equalFoldRight is a specialization of bytes.EqualFold when s is\n// known to be all ASCII (including punctuation), but contains an 's',\n// 'S', 'k', or 'K', requiring a Unicode fold on the bytes in t.\n// See comments on foldFunc.\nfunc equalFoldRight(s, t []byte) bool {\n\tfor _, sb := range s {\n\t\tif len(t) == 0 {\n\t\t\treturn false\n\t\t}\n\t\ttb := t[0]\n\t\tif tb < utf8.RuneSelf {\n\t\t\tif sb != tb {\n\t\t\t\tsbUpper := sb & caseMask\n\t\t\t\tif 'A' <= sbUpper && sbUpper <= 'Z' {\n\t\t\t\t\tif sbUpper != tb&caseMask {\n\t\t\t\t\t\treturn false\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\treturn false\n\t\t\t\t}\n\t\t\t}\n\t\t\tt = t[1:]\n\t\t\tcontinue\n\t\t}\n\t\t// sb is ASCII and t is not. t must be either kelvin\n\t\t// sign or long s; sb must be s, S, k, or K.\n\t\ttr, size := utf8.DecodeRune(t)\n\t\tswitch sb {\n\t\tcase 's', 'S':\n\t\t\tif tr != smallLongEss {\n\t\t\t\treturn false\n\t\t\t}\n\t\tcase 'k', 'K':\n\t\t\tif tr != kelvin {\n\t\t\t\treturn false\n\t\t\t}\n\t\tdefault:\n\t\t\treturn false\n\t\t}\n\t\tt = t[size:]\n\n\t}\n\tif len(t) > 0 {\n\t\treturn false\n\t}\n\treturn true\n}\n\n// asciiEqualFold is a specialization of bytes.EqualFold for use when\n// s is all ASCII (but may contain non-letters) and contains no\n// special-folding letters.\n// See comments on foldFunc.\nfunc asciiEqualFold(s, t []byte) bool {\n\tif len(s) != len(t) {\n\t\treturn false\n\t}\n\tfor i, sb := range s {\n\t\ttb := t[i]\n\t\tif sb == tb {\n\t\t\tcontinue\n\t\t}\n\t\tif ('a' <= sb && sb <= 'z') || ('A' <= sb && sb <= 'Z') {\n\t\t\tif sb&caseMask != tb&caseMask {\n\t\t\t\treturn false\n\t\t\t}\n\t\t} else {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n// simpleLetterEqualFold is a specialization of bytes.EqualFold for\n// use when s is all ASCII letters (no underscores, etc) and also\n// doesn't contain 'k', 'K', 's', or 'S'.\n// See comments on foldFunc.\nfunc simpleLetterEqualFold(s, t []byte) bool {\n\tif len(s) != len(t) {\n\t\treturn false\n\t}\n\tfor i, b := range s {\n\t\tif b&caseMask != t[i]&caseMask {\n\t\t\treturn false\n\t\t}\n\t}\n\treturn true\n}\n\n// tagOptions is the string following a comma in a struct field's \"json\"\n// tag, or the empty string. It does not include the leading comma.\ntype tagOptions string\n\n// parseTag splits a struct field's json tag into its name and\n// comma-separated options.\nfunc parseTag(tag string) (string, tagOptions) {\n\tif idx := strings.Index(tag, \",\"); idx != -1 {\n\t\treturn tag[:idx], tagOptions(tag[idx+1:])\n\t}\n\treturn tag, tagOptions(\"\")\n}\n\n// Contains reports whether a comma-separated list of options\n// contains a particular substr flag. substr must be surrounded by a\n// string boundary or commas.\nfunc (o tagOptions) Contains(optionName string) bool {\n\tif len(o) == 0 {\n\t\treturn false\n\t}\n\ts := string(o)\n\tfor s != \"\" {\n\t\tvar next string\n\t\ti := strings.Index(s, \",\")\n\t\tif i >= 0 {\n\t\t\ts, next = s[:i], s[i+1:]\n\t\t}\n\t\tif s == optionName {\n\t\t\treturn true\n\t\t}\n\t\ts = next\n\t}\n\treturn false\n}\n"
},
{
"path": "vendor/github.com/ghodss/yaml/yaml.go",
"content": "package yaml\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"reflect\"\n\t\"strconv\"\n\n\t\"gopkg.in/yaml.v2\"\n)\n\n// Marshals the object into JSON then converts JSON to YAML and returns the\n// YAML.\nfunc Marshal(o interface{}) ([]byte, error) {\n\tj, err := json.Marshal(o)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"error marshaling into JSON: %v\", err)\n\t}\n\n\ty, err := JSONToYAML(j)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"error converting JSON to YAML: %v\", err)\n\t}\n\n\treturn y, nil\n}\n\n// Converts YAML to JSON then uses JSON to unmarshal into an object.\nfunc Unmarshal(y []byte, o interface{}) error {\n\tvo := reflect.ValueOf(o)\n\tj, err := yamlToJSON(y, &vo)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"error converting YAML to JSON: %v\", err)\n\t}\n\n\terr = json.Unmarshal(j, o)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"error unmarshaling JSON: %v\", err)\n\t}\n\n\treturn nil\n}\n\n// Convert JSON to YAML.\nfunc JSONToYAML(j []byte) ([]byte, error) {\n\t// Convert the JSON to an object.\n\tvar jsonObj interface{}\n\t// We are using yaml.Unmarshal here (instead of json.Unmarshal) because the\n\t// Go JSON library doesn't try to pick the right number type (int, float,\n\t// etc.) when unmarshalling to interface{}, it just picks float64\n\t// universally. go-yaml does go through the effort of picking the right\n\t// number type, so we can preserve number type throughout this process.\n\terr := yaml.Unmarshal(j, &jsonObj)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\t// Marshal this object into YAML.\n\treturn yaml.Marshal(jsonObj)\n}\n\n// Convert YAML to JSON. Since JSON is a subset of YAML, passing JSON through\n// this method should be a no-op.\n//\n// Things YAML can do that are not supported by JSON:\n// * In YAML you can have binary and null keys in your maps. These are invalid\n// in JSON. (int and float keys are converted to strings.)\n// * Binary data in YAML with the !!binary tag is not supported. If you want to\n// use binary data with this library, encode the data as base64 as usual but do\n// not use the !!binary tag in your YAML. This will ensure the original base64\n// encoded data makes it all the way through to the JSON.\nfunc YAMLToJSON(y []byte) ([]byte, error) {\n\treturn yamlToJSON(y, nil)\n}\n\nfunc yamlToJSON(y []byte, jsonTarget *reflect.Value) ([]byte, error) {\n\t// Convert the YAML to an object.\n\tvar yamlObj interface{}\n\terr := yaml.Unmarshal(y, &yamlObj)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\t// YAML objects are not completely compatible with JSON objects (e.g. you\n\t// can have non-string keys in YAML). So, convert the YAML-compatible object\n\t// to a JSON-compatible object, failing with an error if irrecoverable\n\t// incompatibilties happen along the way.\n\tjsonObj, err := convertToJSONableObject(yamlObj, jsonTarget)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\t// Convert this object to JSON and return the data.\n\treturn json.Marshal(jsonObj)\n}\n\nfunc convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) {\n\tvar err error\n\n\t// Resolve jsonTarget to a concrete value (i.e. not a pointer or an\n\t// interface). We pass decodingNull as false because we're not actually\n\t// decoding into the value, we're just checking if the ultimate target is a\n\t// string.\n\tif jsonTarget != nil {\n\t\tju, tu, pv := indirect(*jsonTarget, false)\n\t\t// We have a JSON or Text Umarshaler at this level, so we can't be trying\n\t\t// to decode into a string.\n\t\tif ju != nil || tu != nil {\n\t\t\tjsonTarget = nil\n\t\t} else {\n\t\t\tjsonTarget = &pv\n\t\t}\n\t}\n\n\t// If yamlObj is a number or a boolean, check if jsonTarget is a string -\n\t// if so, coerce. Else return normal.\n\t// If yamlObj is a map or array, find the field that each key is\n\t// unmarshaling to, and when you recurse pass the reflect.Value for that\n\t// field back into this function.\n\tswitch typedYAMLObj := yamlObj.(type) {\n\tcase map[interface{}]interface{}:\n\t\t// JSON does not support arbitrary keys in a map, so we must convert\n\t\t// these keys to strings.\n\t\t//\n\t\t// From my reading of go-yaml v2 (specifically the resolve function),\n\t\t// keys can only have the types string, int, int64, float64, binary\n\t\t// (unsupported), or null (unsupported).\n\t\tstrMap := make(map[string]interface{})\n\t\tfor k, v := range typedYAMLObj {\n\t\t\t// Resolve the key to a string first.\n\t\t\tvar keyString string\n\t\t\tswitch typedKey := k.(type) {\n\t\t\tcase string:\n\t\t\t\tkeyString = typedKey\n\t\t\tcase int:\n\t\t\t\tkeyString = strconv.Itoa(typedKey)\n\t\t\tcase int64:\n\t\t\t\t// go-yaml will only return an int64 as a key if the system\n\t\t\t\t// architecture is 32-bit and the key's value is between 32-bit\n\t\t\t\t// and 64-bit. Otherwise the key type will simply be int.\n\t\t\t\tkeyString = strconv.FormatInt(typedKey, 10)\n\t\t\tcase float64:\n\t\t\t\t// Stolen from go-yaml to use the same conversion to string as\n\t\t\t\t// the go-yaml library uses to convert float to string when\n\t\t\t\t// Marshaling.\n\t\t\t\ts := strconv.FormatFloat(typedKey, 'g', -1, 32)\n\t\t\t\tswitch s {\n\t\t\t\tcase \"+Inf\":\n\t\t\t\t\ts = \".inf\"\n\t\t\t\tcase \"-Inf\":\n\t\t\t\t\ts = \"-.inf\"\n\t\t\t\tcase \"NaN\":\n\t\t\t\t\ts = \".nan\"\n\t\t\t\t}\n\t\t\t\tkeyString = s\n\t\t\tcase bool:\n\t\t\t\tif typedKey {\n\t\t\t\t\tkeyString = \"true\"\n\t\t\t\t} else {\n\t\t\t\t\tkeyString = \"false\"\n\t\t\t\t}\n\t\t\tdefault:\n\t\t\t\treturn nil, fmt.Errorf(\"Unsupported map key of type: %s, key: %+#v, value: %+#v\",\n\t\t\t\t\treflect.TypeOf(k), k, v)\n\t\t\t}\n\n\t\t\t// jsonTarget should be a struct or a map. If it's a struct, find\n\t\t\t// the field it's going to map to and pass its reflect.Value. If\n\t\t\t// it's a map, find the element type of the map and pass the\n\t\t\t// reflect.Value created from that type. If it's neither, just pass\n\t\t\t// nil - JSON conversion will error for us if it's a real issue.\n\t\t\tif jsonTarget != nil {\n\t\t\t\tt := *jsonTarget\n\t\t\t\tif t.Kind() == reflect.Struct {\n\t\t\t\t\tkeyBytes := []byte(keyString)\n\t\t\t\t\t// Find the field that the JSON library would use.\n\t\t\t\t\tvar f *field\n\t\t\t\t\tfields := cachedTypeFields(t.Type())\n\t\t\t\t\tfor i := range fields {\n\t\t\t\t\t\tff := &fields[i]\n\t\t\t\t\t\tif bytes.Equal(ff.nameBytes, keyBytes) {\n\t\t\t\t\t\t\tf = ff\n\t\t\t\t\t\t\tbreak\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Do case-insensitive comparison.\n\t\t\t\t\t\tif f == nil && ff.equalFold(ff.nameBytes, keyBytes) {\n\t\t\t\t\t\t\tf = ff\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif f != nil {\n\t\t\t\t\t\t// Find the reflect.Value of the most preferential\n\t\t\t\t\t\t// struct field.\n\t\t\t\t\t\tjtf := t.Field(f.index[0])\n\t\t\t\t\t\tstrMap[keyString], err = convertToJSONableObject(v, &jtf)\n\t\t\t\t\t\tif err != nil {\n\t\t\t\t\t\t\treturn nil, err\n\t\t\t\t\t\t}\n\t\t\t\t\t\tcontinue\n\t\t\t\t\t}\n\t\t\t\t} else if t.Kind() == reflect.Map {\n\t\t\t\t\t// Create a zero value of the map's element type to use as\n\t\t\t\t\t// the JSON target.\n\t\t\t\t\tjtv := reflect.Zero(t.Type().Elem())\n\t\t\t\t\tstrMap[keyString], err = convertToJSONableObject(v, &jtv)\n\t\t\t\t\tif err != nil {\n\t\t\t\t\t\treturn nil, err\n\t\t\t\t\t}\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t}\n\t\t\tstrMap[keyString], err = convertToJSONableObject(v, nil)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t}\n\t\treturn strMap, nil\n\tcase []interface{}:\n\t\t// We need to recurse into arrays in case there are any\n\t\t// map[interface{}]interface{}'s inside and to convert any\n\t\t// numbers to strings.\n\n\t\t// If jsonTarget is a slice (which it really should be), find the\n\t\t// thing it's going to map to. If it's not a slice, just pass nil\n\t\t// - JSON conversion will error for us if it's a real issue.\n\t\tvar jsonSliceElemValue *reflect.Value\n\t\tif jsonTarget != nil {\n\t\t\tt := *jsonTarget\n\t\t\tif t.Kind() == reflect.Slice {\n\t\t\t\t// By default slices point to nil, but we need a reflect.Value\n\t\t\t\t// pointing to a value of the slice type, so we create one here.\n\t\t\t\tev := reflect.Indirect(reflect.New(t.Type().Elem()))\n\t\t\t\tjsonSliceElemValue = &ev\n\t\t\t}\n\t\t}\n\n\t\t// Make and use a new array.\n\t\tarr := make([]interface{}, len(typedYAMLObj))\n\t\tfor i, v := range typedYAMLObj {\n\t\t\tarr[i], err = convertToJSONableObject(v, jsonSliceElemValue)\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\t\t}\n\t\treturn arr, nil\n\tdefault:\n\t\t// If the target type is a string and the YAML type is a number,\n\t\t// convert the YAML type to a string.\n\t\tif jsonTarget != nil && (*jsonTarget).Kind() == reflect.String {\n\t\t\t// Based on my reading of go-yaml, it may return int, int64,\n\t\t\t// float64, or uint64.\n\t\t\tvar s string\n\t\t\tswitch typedVal := typedYAMLObj.(type) {\n\t\t\tcase int:\n\t\t\t\ts = strconv.FormatInt(int64(typedVal), 10)\n\t\t\tcase int64:\n\t\t\t\ts = strconv.FormatInt(typedVal, 10)\n\t\t\tcase float64:\n\t\t\t\ts = strconv.FormatFloat(typedVal, 'g', -1, 32)\n\t\t\tcase uint64:\n\t\t\t\ts = strconv.FormatUint(typedVal, 10)\n\t\t\tcase bool:\n\t\t\t\tif typedVal {\n\t\t\t\t\ts = \"true\"\n\t\t\t\t} else {\n\t\t\t\t\ts = \"false\"\n\t\t\t\t}\n\t\t\t}\n\t\t\tif len(s) > 0 {\n\t\t\t\tyamlObj = interface{}(s)\n\t\t\t}\n\t\t}\n\t\treturn yamlObj, nil\n\t}\n\n\treturn nil, nil\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/.gitignore",
"content": ".idea\n*.sw?\n.vscode\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/CHANGELOG.md",
"content": "# Changelog\n\n## v5.0.12 (2024-02-16)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.11...v5.0.12\n\n\n## v5.0.11 (2023-12-19)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.10...v5.0.11\n\n\n## v5.0.10 (2023-07-13)\n\n- Fixed small edge case in tests of v5.0.9 for older Go versions\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.9...v5.0.10\n\n\n## v5.0.9 (2023-07-13)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.8...v5.0.9\n\n\n## v5.0.8 (2022-12-07)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.7...v5.0.8\n\n\n## v5.0.7 (2021-11-18)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.6...v5.0.7\n\n\n## v5.0.6 (2021-11-15)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.5...v5.0.6\n\n\n## v5.0.5 (2021-10-27)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.4...v5.0.5\n\n\n## v5.0.4 (2021-08-29)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.3...v5.0.4\n\n\n## v5.0.3 (2021-04-29)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.2...v5.0.3\n\n\n## v5.0.2 (2021-03-25)\n\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.1...v5.0.2\n\n\n## v5.0.1 (2021-03-10)\n\n- Small improvements\n- History of changes: see https://github.com/go-chi/chi/compare/v5.0.0...v5.0.1\n\n\n## v5.0.0 (2021-02-27)\n\n- chi v5, `github.com/go-chi/chi/v5` introduces the adoption of Go's SIV to adhere to the current state-of-the-tools in Go.\n- chi v1.5.x did not work out as planned, as the Go tooling is too powerful and chi's adoption is too wide.\n The most responsible thing to do for everyone's benefit is to just release v5 with SIV, so I present to you all,\n chi v5 at `github.com/go-chi/chi/v5`. I hope someday the developer experience and ergonomics I've been seeking\n will still come to fruition in some form, see https://github.com/golang/go/issues/44550\n- History of changes: see https://github.com/go-chi/chi/compare/v1.5.4...v5.0.0\n\n\n## v1.5.4 (2021-02-27)\n\n- Undo prior retraction in v1.5.3 as we prepare for v5.0.0 release\n- History of changes: see https://github.com/go-chi/chi/compare/v1.5.3...v1.5.4\n\n\n## v1.5.3 (2021-02-21)\n\n- Update go.mod to go 1.16 with new retract directive marking all versions without prior go.mod support\n- History of changes: see https://github.com/go-chi/chi/compare/v1.5.2...v1.5.3\n\n\n## v1.5.2 (2021-02-10)\n\n- Reverting allocation optimization as a precaution as go test -race fails.\n- Minor improvements, see history below\n- History of changes: see https://github.com/go-chi/chi/compare/v1.5.1...v1.5.2\n\n\n## v1.5.1 (2020-12-06)\n\n- Performance improvement: removing 1 allocation by foregoing context.WithValue, thank you @bouk for\n your contribution (https://github.com/go-chi/chi/pull/555). Note: new benchmarks posted in README.\n- `middleware.CleanPath`: new middleware that clean's request path of double slashes\n- deprecate & remove `chi.ServerBaseContext` in favour of stdlib `http.Server#BaseContext`\n- plus other tiny improvements, see full commit history below\n- History of changes: see https://github.com/go-chi/chi/compare/v4.1.2...v1.5.1\n\n\n## v1.5.0 (2020-11-12) - now with go.mod support\n\n`chi` dates back to 2016 with it's original implementation as one of the first routers to adopt the newly introduced\ncontext.Context api to the stdlib -- set out to design a router that is faster, more modular and simpler than anything\nelse out there -- while not introducing any custom handler types or dependencies. Today, `chi` still has zero dependencies,\nand in many ways is future proofed from changes, given it's minimal nature. Between versions, chi's iterations have been very\nincremental, with the architecture and api being the same today as it was originally designed in 2016. For this reason it \nmakes chi a pretty easy project to maintain, as well thanks to the many amazing community contributions over the years\nto who all help make chi better (total of 86 contributors to date -- thanks all!).\n\nChi has been a labour of love, art and engineering, with the goals to offer beautiful ergonomics, flexibility, performance\nand simplicity when building HTTP services with Go. I've strived to keep the router very minimal in surface area / code size,\nand always improving the code wherever possible -- and as of today the `chi` package is just 1082 lines of code (not counting\nmiddlewares, which are all optional). As well, I don't have the exact metrics, but from my analysis and email exchanges from\ncompanies and developers, chi is used by thousands of projects around the world -- thank you all as there is no better form of\njoy for me than to have art I had started be helpful and enjoyed by others. And of course I use chi in all of my own projects too :)\n\nFor me, the aesthetics of chi's code and usage are very important. With the introduction of Go's module support\n(which I'm a big fan of), chi's past versioning scheme choice to v2, v3 and v4 would mean I'd require the import path\nof \"github.com/go-chi/chi/v4\", leading to the lengthy discussion at https://github.com/go-chi/chi/issues/462.\nHaha, to some, you may be scratching your head why I've spent > 1 year stalling to adopt \"/vXX\" convention in the import\npath -- which isn't horrible in general -- but for chi, I'm unable to accept it as I strive for perfection in it's API design,\naesthetics and simplicity. It just doesn't feel good to me given chi's simple nature -- I do not foresee a \"v5\" or \"v6\",\nand upgrading between versions in the future will also be just incremental.\n\nI do understand versioning is a part of the API design as well, which is why the solution for a while has been to \"do nothing\",\nas Go supports both old and new import paths with/out go.mod. However, now that Go module support has had time to iron out kinks and\nis adopted everywhere, it's time for chi to get with the times. Luckily, I've discovered a path forward that will make me happy,\nwhile also not breaking anyone's app who adopted a prior versioning from tags in v2/v3/v4. I've made an experimental release of\nv1.5.0 with go.mod silently, and tested it with new and old projects, to ensure the developer experience is preserved, and it's\nlargely unnoticed. Fortunately, Go's toolchain will check the tags of a repo and consider the \"latest\" tag the one with go.mod.\nHowever, you can still request a specific older tag such as v4.1.2, and everything will \"just work\". But new users can just\n`go get github.com/go-chi/chi` or `go get github.com/go-chi/chi@latest` and they will get the latest version which contains\ngo.mod support, which is v1.5.0+. `chi` will not change very much over the years, just like it hasn't changed much from 4 years ago.\nTherefore, we will stay on v1.x from here on, starting from v1.5.0. Any breaking changes will bump a \"minor\" release and\nbackwards-compatible improvements/fixes will bump a \"tiny\" release.\n\nFor existing projects who want to upgrade to the latest go.mod version, run: `go get -u github.com/go-chi/chi@v1.5.0`,\nwhich will get you on the go.mod version line (as Go's mod cache may still remember v4.x). Brand new systems can run\n`go get -u github.com/go-chi/chi` or `go get -u github.com/go-chi/chi@latest` to install chi, which will install v1.5.0+\nbuilt with go.mod support.\n\nMy apologies to the developers who will disagree with the decisions above, but, hope you'll try it and see it's a very\nminor request which is backwards compatible and won't break your existing installations.\n\nCheers all, happy coding!\n\n\n---\n\n\n## v4.1.2 (2020-06-02)\n\n- fix that handles MethodNotAllowed with path variables, thank you @caseyhadden for your contribution\n- fix to replace nested wildcards correctly in RoutePattern, thank you @@unmultimedio for your contribution\n- History of changes: see https://github.com/go-chi/chi/compare/v4.1.1...v4.1.2\n\n\n## v4.1.1 (2020-04-16)\n\n- fix for issue https://github.com/go-chi/chi/issues/411 which allows for overlapping regexp\n route to the correct handler through a recursive tree search, thanks to @Jahaja for the PR/fix!\n- new middleware.RouteHeaders as a simple router for request headers with wildcard support\n- History of changes: see https://github.com/go-chi/chi/compare/v4.1.0...v4.1.1\n\n\n## v4.1.0 (2020-04-1)\n\n- middleware.LogEntry: Write method on interface now passes the response header\n and an extra interface type useful for custom logger implementations.\n- middleware.WrapResponseWriter: minor fix\n- middleware.Recoverer: a bit prettier\n- History of changes: see https://github.com/go-chi/chi/compare/v4.0.4...v4.1.0\n\n## v4.0.4 (2020-03-24)\n\n- middleware.Recoverer: new pretty stack trace printing (https://github.com/go-chi/chi/pull/496)\n- a few minor improvements and fixes\n- History of changes: see https://github.com/go-chi/chi/compare/v4.0.3...v4.0.4\n\n\n## v4.0.3 (2020-01-09)\n\n- core: fix regexp routing to include default value when param is not matched\n- middleware: rewrite of middleware.Compress\n- middleware: suppress http.ErrAbortHandler in middleware.Recoverer\n- History of changes: see https://github.com/go-chi/chi/compare/v4.0.2...v4.0.3\n\n\n## v4.0.2 (2019-02-26)\n\n- Minor fixes\n- History of changes: see https://github.com/go-chi/chi/compare/v4.0.1...v4.0.2\n\n\n## v4.0.1 (2019-01-21)\n\n- Fixes issue with compress middleware: #382 #385\n- History of changes: see https://github.com/go-chi/chi/compare/v4.0.0...v4.0.1\n\n\n## v4.0.0 (2019-01-10)\n\n- chi v4 requires Go 1.10.3+ (or Go 1.9.7+) - we have deprecated support for Go 1.7 and 1.8\n- router: respond with 404 on router with no routes (#362)\n- router: additional check to ensure wildcard is at the end of a url pattern (#333)\n- middleware: deprecate use of http.CloseNotifier (#347)\n- middleware: fix RedirectSlashes to include query params on redirect (#334)\n- History of changes: see https://github.com/go-chi/chi/compare/v3.3.4...v4.0.0\n\n\n## v3.3.4 (2019-01-07)\n\n- Minor middleware improvements. No changes to core library/router. Moving v3 into its\n- own branch as a version of chi for Go 1.7, 1.8, 1.9, 1.10, 1.11\n- History of changes: see https://github.com/go-chi/chi/compare/v3.3.3...v3.3.4\n\n\n## v3.3.3 (2018-08-27)\n\n- Minor release\n- See https://github.com/go-chi/chi/compare/v3.3.2...v3.3.3\n\n\n## v3.3.2 (2017-12-22)\n\n- Support to route trailing slashes on mounted sub-routers (#281)\n- middleware: new `ContentCharset` to check matching charsets. Thank you\n @csucu for your community contribution!\n\n\n## v3.3.1 (2017-11-20)\n\n- middleware: new `AllowContentType` handler for explicit whitelist of accepted request Content-Types\n- middleware: new `SetHeader` handler for short-hand middleware to set a response header key/value\n- Minor bug fixes\n\n\n## v3.3.0 (2017-10-10)\n\n- New chi.RegisterMethod(method) to add support for custom HTTP methods, see _examples/custom-method for usage\n- Deprecated LINK and UNLINK methods from the default list, please use `chi.RegisterMethod(\"LINK\")` and `chi.RegisterMethod(\"UNLINK\")` in an `init()` function\n\n\n## v3.2.1 (2017-08-31)\n\n- Add new `Match(rctx *Context, method, path string) bool` method to `Routes` interface\n and `Mux`. Match searches the mux's routing tree for a handler that matches the method/path\n- Add new `RouteMethod` to `*Context`\n- Add new `Routes` pointer to `*Context`\n- Add new `middleware.GetHead` to route missing HEAD requests to GET handler\n- Updated benchmarks (see README)\n\n\n## v3.1.5 (2017-08-02)\n\n- Setup golint and go vet for the project\n- As per golint, we've redefined `func ServerBaseContext(h http.Handler, baseCtx context.Context) http.Handler`\n to `func ServerBaseContext(baseCtx context.Context, h http.Handler) http.Handler`\n\n\n## v3.1.0 (2017-07-10)\n\n- Fix a few minor issues after v3 release\n- Move `docgen` sub-pkg to https://github.com/go-chi/docgen\n- Move `render` sub-pkg to https://github.com/go-chi/render\n- Add new `URLFormat` handler to chi/middleware sub-pkg to make working with url mime \n suffixes easier, ie. parsing `/articles/1.json` and `/articles/1.xml`. See comments in\n https://github.com/go-chi/chi/blob/master/middleware/url_format.go for example usage.\n\n\n## v3.0.0 (2017-06-21)\n\n- Major update to chi library with many exciting updates, but also some *breaking changes*\n- URL parameter syntax changed from `/:id` to `/{id}` for even more flexible routing, such as\n `/articles/{month}-{day}-{year}-{slug}`, `/articles/{id}`, and `/articles/{id}.{ext}` on the\n same router\n- Support for regexp for routing patterns, in the form of `/{paramKey:regExp}` for example:\n `r.Get(\"/articles/{name:[a-z]+}\", h)` and `chi.URLParam(r, \"name\")`\n- Add `Method` and `MethodFunc` to `chi.Router` to allow routing definitions such as\n `r.Method(\"GET\", \"/\", h)` which provides a cleaner interface for custom handlers like\n in `_examples/custom-handler`\n- Deprecating `mux#FileServer` helper function. Instead, we encourage users to create their\n own using file handler with the stdlib, see `_examples/fileserver` for an example\n- Add support for LINK/UNLINK http methods via `r.Method()` and `r.MethodFunc()`\n- Moved the chi project to its own organization, to allow chi-related community packages to\n be easily discovered and supported, at: https://github.com/go-chi\n- *NOTE:* please update your import paths to `\"github.com/go-chi/chi\"`\n- *NOTE:* chi v2 is still available at https://github.com/go-chi/chi/tree/v2\n\n\n## v2.1.0 (2017-03-30)\n\n- Minor improvements and update to the chi core library\n- Introduced a brand new `chi/render` sub-package to complete the story of building\n APIs to offer a pattern for managing well-defined request / response payloads. Please\n check out the updated `_examples/rest` example for how it works.\n- Added `MethodNotAllowed(h http.HandlerFunc)` to chi.Router interface\n\n\n## v2.0.0 (2017-01-06)\n\n- After many months of v2 being in an RC state with many companies and users running it in\n production, the inclusion of some improvements to the middlewares, we are very pleased to\n announce v2.0.0 of chi.\n\n\n## v2.0.0-rc1 (2016-07-26)\n\n- Huge update! chi v2 is a large refactor targeting Go 1.7+. As of Go 1.7, the popular\n community `\"net/context\"` package has been included in the standard library as `\"context\"` and\n utilized by `\"net/http\"` and `http.Request` to managing deadlines, cancelation signals and other\n request-scoped values. We're very excited about the new context addition and are proud to\n introduce chi v2, a minimal and powerful routing package for building large HTTP services,\n with zero external dependencies. Chi focuses on idiomatic design and encourages the use of \n stdlib HTTP handlers and middlewares.\n- chi v2 deprecates its `chi.Handler` interface and requires `http.Handler` or `http.HandlerFunc`\n- chi v2 stores URL routing parameters and patterns in the standard request context: `r.Context()`\n- chi v2 lower-level routing context is accessible by `chi.RouteContext(r.Context()) *chi.Context`,\n which provides direct access to URL routing parameters, the routing path and the matching\n routing patterns.\n- Users upgrading from chi v1 to v2, need to:\n 1. Update the old chi.Handler signature, `func(ctx context.Context, w http.ResponseWriter, r *http.Request)` to\n the standard http.Handler: `func(w http.ResponseWriter, r *http.Request)`\n 2. Use `chi.URLParam(r *http.Request, paramKey string) string`\n or `URLParamFromCtx(ctx context.Context, paramKey string) string` to access a url parameter value\n\n\n## v1.0.0 (2016-07-01)\n\n- Released chi v1 stable https://github.com/go-chi/chi/tree/v1.0.0 for Go 1.6 and older.\n\n\n## v0.9.0 (2016-03-31)\n\n- Reuse context objects via sync.Pool for zero-allocation routing [#33](https://github.com/go-chi/chi/pull/33)\n- BREAKING NOTE: due to subtle API changes, previously `chi.URLParams(ctx)[\"id\"]` used to access url parameters\n has changed to: `chi.URLParam(ctx, \"id\")`\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/CONTRIBUTING.md",
"content": "# Contributing\n\n## Prerequisites\n\n1. [Install Go][go-install].\n2. Download the sources and switch the working directory:\n\n ```bash\n go get -u -d github.com/go-chi/chi\n cd $GOPATH/src/github.com/go-chi/chi\n ```\n\n## Submitting a Pull Request\n\nA typical workflow is:\n\n1. [Fork the repository.][fork] [This tip maybe also helpful.][go-fork-tip]\n2. [Create a topic branch.][branch]\n3. Add tests for your change.\n4. Run `go test`. If your tests pass, return to the step 3.\n5. Implement the change and ensure the steps from the previous step pass.\n6. Run `goimports -w .`, to ensure the new code conforms to Go formatting guideline.\n7. [Add, commit and push your changes.][git-help]\n8. [Submit a pull request.][pull-req]\n\n[go-install]: https://golang.org/doc/install\n[go-fork-tip]: http://blog.campoy.cat/2014/03/github-and-go-forking-pull-requests-and.html\n[fork]: https://help.github.com/articles/fork-a-repo\n[branch]: http://learn.github.com/p/branching.html\n[git-help]: https://guides.github.com\n[pull-req]: https://help.github.com/articles/using-pull-requests\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/LICENSE",
"content": "Copyright (c) 2015-present Peter Kieltyka (https://github.com/pkieltyka), Google Inc.\n\nMIT License\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software is furnished to do so,\nsubject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\nFOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\nCOPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\nIN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\nCONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/Makefile",
"content": ".PHONY: all\nall:\n\t@echo \"**********************************************************\"\n\t@echo \"** chi build tool **\"\n\t@echo \"**********************************************************\"\n\n\n.PHONY: test\ntest:\n\tgo clean -testcache && $(MAKE) test-router && $(MAKE) test-middleware\n\n.PHONY: test-router\ntest-router:\n\tgo test -race -v .\n\n.PHONY: test-middleware\ntest-middleware:\n\tgo test -race -v ./middleware\n\n.PHONY: docs\ndocs:\n\tnpx docsify-cli serve ./docs\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/README.md",
"content": "# ![\"chi\"](\"https://cdn.rawgit.com/go-chi/chi/master/_examples/chi.svg\")
\n\n\n[![GoDoc Widget]][GoDoc]\n\n`chi` is a lightweight, idiomatic and composable router for building Go HTTP services. It's\nespecially good at helping you write large REST API services that are kept maintainable as your\nproject grows and changes. `chi` is built on the new `context` package introduced in Go 1.7 to\nhandle signaling, cancelation and request-scoped values across a handler chain.\n\nThe focus of the project has been to seek out an elegant and comfortable design for writing\nREST API servers, written during the development of the Pressly API service that powers our\npublic API service, which in turn powers all of our client-side applications.\n\nThe key considerations of chi's design are: project structure, maintainability, standard http\nhandlers (stdlib-only), developer productivity, and deconstructing a large system into many small\nparts. The core router `github.com/go-chi/chi` is quite small (less than 1000 LOC), but we've also\nincluded some useful/optional subpackages: [middleware](/middleware), [render](https://github.com/go-chi/render)\nand [docgen](https://github.com/go-chi/docgen). We hope you enjoy it too!\n\n## Install\n\n`go get -u github.com/go-chi/chi/v5`\n\n\n## Features\n\n* **Lightweight** - cloc'd in ~1000 LOC for the chi router\n* **Fast** - yes, see [benchmarks](#benchmarks)\n* **100% compatible with net/http** - use any http or middleware pkg in the ecosystem that is also compatible with `net/http`\n* **Designed for modular/composable APIs** - middlewares, inline middlewares, route groups and sub-router mounting\n* **Context control** - built on new `context` package, providing value chaining, cancellations and timeouts\n* **Robust** - in production at Pressly, Cloudflare, Heroku, 99Designs, and many others (see [discussion](https://github.com/go-chi/chi/issues/91))\n* **Doc generation** - `docgen` auto-generates routing documentation from your source to JSON or Markdown\n* **Go.mod support** - as of v5, go.mod support (see [CHANGELOG](https://github.com/go-chi/chi/blob/master/CHANGELOG.md))\n* **No external dependencies** - plain ol' Go stdlib + net/http\n\n\n## Examples\n\nSee [_examples/](https://github.com/go-chi/chi/blob/master/_examples/) for a variety of examples.\n\n\n**As easy as:**\n\n```go\npackage main\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/go-chi/chi/v5\"\n\t\"github.com/go-chi/chi/v5/middleware\"\n)\n\nfunc main() {\n\tr := chi.NewRouter()\n\tr.Use(middleware.Logger)\n\tr.Get(\"/\", func(w http.ResponseWriter, r *http.Request) {\n\t\tw.Write([]byte(\"welcome\"))\n\t})\n\thttp.ListenAndServe(\":3000\", r)\n}\n```\n\n**REST Preview:**\n\nHere is a little preview of how routing looks like with chi. Also take a look at the generated routing docs\nin JSON ([routes.json](https://github.com/go-chi/chi/blob/master/_examples/rest/routes.json)) and in\nMarkdown ([routes.md](https://github.com/go-chi/chi/blob/master/_examples/rest/routes.md)).\n\nI highly recommend reading the source of the [examples](https://github.com/go-chi/chi/blob/master/_examples/) listed\nabove, they will show you all the features of chi and serve as a good form of documentation.\n\n```go\nimport (\n //...\n \"context\"\n \"github.com/go-chi/chi/v5\"\n \"github.com/go-chi/chi/v5/middleware\"\n)\n\nfunc main() {\n r := chi.NewRouter()\n\n // A good base middleware stack\n r.Use(middleware.RequestID)\n r.Use(middleware.RealIP)\n r.Use(middleware.Logger)\n r.Use(middleware.Recoverer)\n\n // Set a timeout value on the request context (ctx), that will signal\n // through ctx.Done() that the request has timed out and further\n // processing should be stopped.\n r.Use(middleware.Timeout(60 * time.Second))\n\n r.Get(\"/\", func(w http.ResponseWriter, r *http.Request) {\n w.Write([]byte(\"hi\"))\n })\n\n // RESTy routes for \"articles\" resource\n r.Route(\"/articles\", func(r chi.Router) {\n r.With(paginate).Get(\"/\", listArticles) // GET /articles\n r.With(paginate).Get(\"/{month}-{day}-{year}\", listArticlesByDate) // GET /articles/01-16-2017\n\n r.Post(\"/\", createArticle) // POST /articles\n r.Get(\"/search\", searchArticles) // GET /articles/search\n\n // Regexp url parameters:\n r.Get(\"/{articleSlug:[a-z-]+}\", getArticleBySlug) // GET /articles/home-is-toronto\n\n // Subrouters:\n r.Route(\"/{articleID}\", func(r chi.Router) {\n r.Use(ArticleCtx)\n r.Get(\"/\", getArticle) // GET /articles/123\n r.Put(\"/\", updateArticle) // PUT /articles/123\n r.Delete(\"/\", deleteArticle) // DELETE /articles/123\n })\n })\n\n // Mount the admin sub-router\n r.Mount(\"/admin\", adminRouter())\n\n http.ListenAndServe(\":3333\", r)\n}\n\nfunc ArticleCtx(next http.Handler) http.Handler {\n return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n articleID := chi.URLParam(r, \"articleID\")\n article, err := dbGetArticle(articleID)\n if err != nil {\n http.Error(w, http.StatusText(404), 404)\n return\n }\n ctx := context.WithValue(r.Context(), \"article\", article)\n next.ServeHTTP(w, r.WithContext(ctx))\n })\n}\n\nfunc getArticle(w http.ResponseWriter, r *http.Request) {\n ctx := r.Context()\n article, ok := ctx.Value(\"article\").(*Article)\n if !ok {\n http.Error(w, http.StatusText(422), 422)\n return\n }\n w.Write([]byte(fmt.Sprintf(\"title:%s\", article.Title)))\n}\n\n// A completely separate router for administrator routes\nfunc adminRouter() http.Handler {\n r := chi.NewRouter()\n r.Use(AdminOnly)\n r.Get(\"/\", adminIndex)\n r.Get(\"/accounts\", adminListAccounts)\n return r\n}\n\nfunc AdminOnly(next http.Handler) http.Handler {\n return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n ctx := r.Context()\n perm, ok := ctx.Value(\"acl.permission\").(YourPermissionType)\n if !ok || !perm.IsAdmin() {\n http.Error(w, http.StatusText(403), 403)\n return\n }\n next.ServeHTTP(w, r)\n })\n}\n```\n\n\n## Router interface\n\nchi's router is based on a kind of [Patricia Radix trie](https://en.wikipedia.org/wiki/Radix_tree).\nThe router is fully compatible with `net/http`.\n\nBuilt on top of the tree is the `Router` interface:\n\n```go\n// Router consisting of the core routing methods used by chi's Mux,\n// using only the standard net/http.\ntype Router interface {\n\thttp.Handler\n\tRoutes\n\n\t// Use appends one or more middlewares onto the Router stack.\n\tUse(middlewares ...func(http.Handler) http.Handler)\n\n\t// With adds inline middlewares for an endpoint handler.\n\tWith(middlewares ...func(http.Handler) http.Handler) Router\n\n\t// Group adds a new inline-Router along the current routing\n\t// path, with a fresh middleware stack for the inline-Router.\n\tGroup(fn func(r Router)) Router\n\n\t// Route mounts a sub-Router along a `pattern`` string.\n\tRoute(pattern string, fn func(r Router)) Router\n\n\t// Mount attaches another http.Handler along ./pattern/*\n\tMount(pattern string, h http.Handler)\n\n\t// Handle and HandleFunc adds routes for `pattern` that matches\n\t// all HTTP methods.\n\tHandle(pattern string, h http.Handler)\n\tHandleFunc(pattern string, h http.HandlerFunc)\n\n\t// Method and MethodFunc adds routes for `pattern` that matches\n\t// the `method` HTTP method.\n\tMethod(method, pattern string, h http.Handler)\n\tMethodFunc(method, pattern string, h http.HandlerFunc)\n\n\t// HTTP-method routing along `pattern`\n\tConnect(pattern string, h http.HandlerFunc)\n\tDelete(pattern string, h http.HandlerFunc)\n\tGet(pattern string, h http.HandlerFunc)\n\tHead(pattern string, h http.HandlerFunc)\n\tOptions(pattern string, h http.HandlerFunc)\n\tPatch(pattern string, h http.HandlerFunc)\n\tPost(pattern string, h http.HandlerFunc)\n\tPut(pattern string, h http.HandlerFunc)\n\tTrace(pattern string, h http.HandlerFunc)\n\n\t// NotFound defines a handler to respond whenever a route could\n\t// not be found.\n\tNotFound(h http.HandlerFunc)\n\n\t// MethodNotAllowed defines a handler to respond whenever a method is\n\t// not allowed.\n\tMethodNotAllowed(h http.HandlerFunc)\n}\n\n// Routes interface adds two methods for router traversal, which is also\n// used by the github.com/go-chi/docgen package to generate documentation for Routers.\ntype Routes interface {\n\t// Routes returns the routing tree in an easily traversable structure.\n\tRoutes() []Route\n\n\t// Middlewares returns the list of middlewares in use by the router.\n\tMiddlewares() Middlewares\n\n\t// Match searches the routing tree for a handler that matches\n\t// the method/path - similar to routing a http request, but without\n\t// executing the handler thereafter.\n\tMatch(rctx *Context, method, path string) bool\n}\n```\n\nEach routing method accepts a URL `pattern` and chain of `handlers`. The URL pattern\nsupports named params (ie. `/users/{userID}`) and wildcards (ie. `/admin/*`). URL parameters\ncan be fetched at runtime by calling `chi.URLParam(r, \"userID\")` for named parameters\nand `chi.URLParam(r, \"*\")` for a wildcard parameter.\n\n\n### Middleware handlers\n\nchi's middlewares are just stdlib net/http middleware handlers. There is nothing special\nabout them, which means the router and all the tooling is designed to be compatible and\nfriendly with any middleware in the community. This offers much better extensibility and reuse\nof packages and is at the heart of chi's purpose.\n\nHere is an example of a standard net/http middleware where we assign a context key `\"user\"`\nthe value of `\"123\"`. This middleware sets a hypothetical user identifier on the request\ncontext and calls the next handler in the chain.\n\n```go\n// HTTP middleware setting a value on the request context\nfunc MyMiddleware(next http.Handler) http.Handler {\n return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n // create new context from `r` request context, and assign key `\"user\"`\n // to value of `\"123\"`\n ctx := context.WithValue(r.Context(), \"user\", \"123\")\n\n // call the next handler in the chain, passing the response writer and\n // the updated request object with the new context value.\n //\n // note: context.Context values are nested, so any previously set\n // values will be accessible as well, and the new `\"user\"` key\n // will be accessible from this point forward.\n next.ServeHTTP(w, r.WithContext(ctx))\n })\n}\n```\n\n\n### Request handlers\n\nchi uses standard net/http request handlers. This little snippet is an example of a http.Handler\nfunc that reads a user identifier from the request context - hypothetically, identifying\nthe user sending an authenticated request, validated+set by a previous middleware handler.\n\n```go\n// HTTP handler accessing data from the request context.\nfunc MyRequestHandler(w http.ResponseWriter, r *http.Request) {\n // here we read from the request context and fetch out `\"user\"` key set in\n // the MyMiddleware example above.\n user := r.Context().Value(\"user\").(string)\n\n // respond to the client\n w.Write([]byte(fmt.Sprintf(\"hi %s\", user)))\n}\n```\n\n\n### URL parameters\n\nchi's router parses and stores URL parameters right onto the request context. Here is\nan example of how to access URL params in your net/http handlers. And of course, middlewares\nare able to access the same information.\n\n```go\n// HTTP handler accessing the url routing parameters.\nfunc MyRequestHandler(w http.ResponseWriter, r *http.Request) {\n // fetch the url parameter `\"userID\"` from the request of a matching\n // routing pattern. An example routing pattern could be: /users/{userID}\n userID := chi.URLParam(r, \"userID\")\n\n // fetch `\"key\"` from the request context\n ctx := r.Context()\n key := ctx.Value(\"key\").(string)\n\n // respond to the client\n w.Write([]byte(fmt.Sprintf(\"hi %v, %v\", userID, key)))\n}\n```\n\n\n## Middlewares\n\nchi comes equipped with an optional `middleware` package, providing a suite of standard\n`net/http` middlewares. Please note, any middleware in the ecosystem that is also compatible\nwith `net/http` can be used with chi's mux.\n\n### Core middlewares\n\n----------------------------------------------------------------------------------------------------\n| chi/middleware Handler | description |\n| :--------------------- | :---------------------------------------------------------------------- |\n| [AllowContentEncoding] | Enforces a whitelist of request Content-Encoding headers |\n| [AllowContentType] | Explicit whitelist of accepted request Content-Types |\n| [BasicAuth] | Basic HTTP authentication |\n| [Compress] | Gzip compression for clients that accept compressed responses |\n| [ContentCharset] | Ensure charset for Content-Type request headers |\n| [CleanPath] | Clean double slashes from request path |\n| [GetHead] | Automatically route undefined HEAD requests to GET handlers |\n| [Heartbeat] | Monitoring endpoint to check the servers pulse |\n| [Logger] | Logs the start and end of each request with the elapsed processing time |\n| [NoCache] | Sets response headers to prevent clients from caching |\n| [Profiler] | Easily attach net/http/pprof to your routers |\n| [RealIP] | Sets a http.Request's RemoteAddr to either X-Real-IP or X-Forwarded-For |\n| [Recoverer] | Gracefully absorb panics and prints the stack trace |\n| [RequestID] | Injects a request ID into the context of each request |\n| [RedirectSlashes] | Redirect slashes on routing paths |\n| [RouteHeaders] | Route handling for request headers |\n| [SetHeader] | Short-hand middleware to set a response header key/value |\n| [StripSlashes] | Strip slashes on routing paths |\n| [Sunset] | Sunset set Deprecation/Sunset header to response |\n| [Throttle] | Puts a ceiling on the number of concurrent requests |\n| [Timeout] | Signals to the request context when the timeout deadline is reached |\n| [URLFormat] | Parse extension from url and put it on request context |\n| [WithValue] | Short-hand middleware to set a key/value on the request context |\n----------------------------------------------------------------------------------------------------\n\n[AllowContentEncoding]: https://pkg.go.dev/github.com/go-chi/chi/middleware#AllowContentEncoding\n[AllowContentType]: https://pkg.go.dev/github.com/go-chi/chi/middleware#AllowContentType\n[BasicAuth]: https://pkg.go.dev/github.com/go-chi/chi/middleware#BasicAuth\n[Compress]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Compress\n[ContentCharset]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ContentCharset\n[CleanPath]: https://pkg.go.dev/github.com/go-chi/chi/middleware#CleanPath\n[GetHead]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetHead\n[GetReqID]: https://pkg.go.dev/github.com/go-chi/chi/middleware#GetReqID\n[Heartbeat]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Heartbeat\n[Logger]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Logger\n[NoCache]: https://pkg.go.dev/github.com/go-chi/chi/middleware#NoCache\n[Profiler]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Profiler\n[RealIP]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RealIP\n[Recoverer]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Recoverer\n[RedirectSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RedirectSlashes\n[RequestLogger]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RequestLogger\n[RequestID]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RequestID\n[RouteHeaders]: https://pkg.go.dev/github.com/go-chi/chi/middleware#RouteHeaders\n[SetHeader]: https://pkg.go.dev/github.com/go-chi/chi/middleware#SetHeader\n[StripSlashes]: https://pkg.go.dev/github.com/go-chi/chi/middleware#StripSlashes\n[Sunset]: https://pkg.go.dev/github.com/go-chi/chi/v5/middleware#Sunset\n[Throttle]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Throttle\n[ThrottleBacklog]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleBacklog\n[ThrottleWithOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleWithOpts\n[Timeout]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Timeout\n[URLFormat]: https://pkg.go.dev/github.com/go-chi/chi/middleware#URLFormat\n[WithLogEntry]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WithLogEntry\n[WithValue]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WithValue\n[Compressor]: https://pkg.go.dev/github.com/go-chi/chi/middleware#Compressor\n[DefaultLogFormatter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#DefaultLogFormatter\n[EncoderFunc]: https://pkg.go.dev/github.com/go-chi/chi/middleware#EncoderFunc\n[HeaderRoute]: https://pkg.go.dev/github.com/go-chi/chi/middleware#HeaderRoute\n[HeaderRouter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#HeaderRouter\n[LogEntry]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LogEntry\n[LogFormatter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LogFormatter\n[LoggerInterface]: https://pkg.go.dev/github.com/go-chi/chi/middleware#LoggerInterface\n[ThrottleOpts]: https://pkg.go.dev/github.com/go-chi/chi/middleware#ThrottleOpts\n[WrapResponseWriter]: https://pkg.go.dev/github.com/go-chi/chi/middleware#WrapResponseWriter\n\n### Extra middlewares & packages\n\nPlease see https://github.com/go-chi for additional packages.\n\n--------------------------------------------------------------------------------------------------------------------\n| package | description |\n|:---------------------------------------------------|:-------------------------------------------------------------\n| [cors](https://github.com/go-chi/cors) | Cross-origin resource sharing (CORS) |\n| [docgen](https://github.com/go-chi/docgen) | Print chi.Router routes at runtime |\n| [jwtauth](https://github.com/go-chi/jwtauth) | JWT authentication |\n| [hostrouter](https://github.com/go-chi/hostrouter) | Domain/host based request routing |\n| [httplog](https://github.com/go-chi/httplog) | Small but powerful structured HTTP request logging |\n| [httprate](https://github.com/go-chi/httprate) | HTTP request rate limiter |\n| [httptracer](https://github.com/go-chi/httptracer) | HTTP request performance tracing library |\n| [httpvcr](https://github.com/go-chi/httpvcr) | Write deterministic tests for external sources |\n| [stampede](https://github.com/go-chi/stampede) | HTTP request coalescer |\n--------------------------------------------------------------------------------------------------------------------\n\n\n## context?\n\n`context` is a tiny pkg that provides simple interface to signal context across call stacks\nand goroutines. It was originally written by [Sameer Ajmani](https://github.com/Sajmani)\nand is available in stdlib since go1.7.\n\nLearn more at https://blog.golang.org/context\n\nand..\n* Docs: https://golang.org/pkg/context\n* Source: https://github.com/golang/go/tree/master/src/context\n\n\n## Benchmarks\n\nThe benchmark suite: https://github.com/pkieltyka/go-http-routing-benchmark\n\nResults as of Nov 29, 2020 with Go 1.15.5 on Linux AMD 3950x\n\n```shell\nBenchmarkChi_Param \t3075895\t 384 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_Param5 \t2116603\t 566 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_Param20 \t 964117\t 1227 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_ParamWrite \t2863413\t 420 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_GithubStatic \t3045488\t 395 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_GithubParam \t2204115\t 540 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_GithubAll \t 10000\t 113811 ns/op\t 81203 B/op 406 allocs/op\nBenchmarkChi_GPlusStatic \t3337485\t 359 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_GPlusParam \t2825853\t 423 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_GPlus2Params \t2471697\t 483 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_GPlusAll \t 194220\t 5950 ns/op\t 5200 B/op 26 allocs/op\nBenchmarkChi_ParseStatic \t3365324\t 356 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_ParseParam \t2976614\t 404 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_Parse2Params \t2638084\t 439 ns/op\t 400 B/op 2 allocs/op\nBenchmarkChi_ParseAll \t 109567\t 11295 ns/op\t 10400 B/op 52 allocs/op\nBenchmarkChi_StaticAll \t 16846\t 71308 ns/op\t 62802 B/op 314 allocs/op\n```\n\nComparison with other routers: https://gist.github.com/pkieltyka/123032f12052520aaccab752bd3e78cc\n\nNOTE: the allocs in the benchmark above are from the calls to http.Request's\n`WithContext(context.Context)` method that clones the http.Request, sets the `Context()`\non the duplicated (alloc'd) request and returns it the new request object. This is just\nhow setting context on a request in Go works.\n\n\n## Credits\n\n* Carl Jackson for https://github.com/zenazn/goji\n * Parts of chi's thinking comes from goji, and chi's middleware package\n sources from goji.\n* Armon Dadgar for https://github.com/armon/go-radix\n* Contributions: [@VojtechVitek](https://github.com/VojtechVitek)\n\nWe'll be more than happy to see [your contributions](./CONTRIBUTING.md)!\n\n\n## Beyond REST\n\nchi is just a http router that lets you decompose request handling into many smaller layers.\nMany companies use chi to write REST services for their public APIs. But, REST is just a convention\nfor managing state via HTTP, and there's a lot of other pieces required to write a complete client-server\nsystem or network of microservices.\n\nLooking beyond REST, I also recommend some newer works in the field:\n* [webrpc](https://github.com/webrpc/webrpc) - Web-focused RPC client+server framework with code-gen\n* [gRPC](https://github.com/grpc/grpc-go) - Google's RPC framework via protobufs\n* [graphql](https://github.com/99designs/gqlgen) - Declarative query language\n* [NATS](https://nats.io) - lightweight pub-sub\n\n\n## License\n\nCopyright (c) 2015-present [Peter Kieltyka](https://github.com/pkieltyka)\n\nLicensed under [MIT License](./LICENSE)\n\n[GoDoc]: https://pkg.go.dev/github.com/go-chi/chi/v5\n[GoDoc Widget]: https://godoc.org/github.com/go-chi/chi?status.svg\n[Travis]: https://travis-ci.org/go-chi/chi\n[Travis Widget]: https://travis-ci.org/go-chi/chi.svg?branch=master\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/SECURITY.md",
"content": "# Reporting Security Issues\n\nWe appreciate your efforts to responsibly disclose your findings, and will make every effort to acknowledge your contributions.\n\nTo report a security issue, please use the GitHub Security Advisory [\"Report a Vulnerability\"](https://github.com/go-chi/chi/security/advisories/new) tab.\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/chain.go",
"content": "package chi\n\nimport \"net/http\"\n\n// Chain returns a Middlewares type from a slice of middleware handlers.\nfunc Chain(middlewares ...func(http.Handler) http.Handler) Middlewares {\n\treturn Middlewares(middlewares)\n}\n\n// Handler builds and returns a http.Handler from the chain of middlewares,\n// with `h http.Handler` as the final handler.\nfunc (mws Middlewares) Handler(h http.Handler) http.Handler {\n\treturn &ChainHandler{h, chain(mws, h), mws}\n}\n\n// HandlerFunc builds and returns a http.Handler from the chain of middlewares,\n// with `h http.Handler` as the final handler.\nfunc (mws Middlewares) HandlerFunc(h http.HandlerFunc) http.Handler {\n\treturn &ChainHandler{h, chain(mws, h), mws}\n}\n\n// ChainHandler is a http.Handler with support for handler composition and\n// execution.\ntype ChainHandler struct {\n\tEndpoint http.Handler\n\tchain http.Handler\n\tMiddlewares Middlewares\n}\n\nfunc (c *ChainHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n\tc.chain.ServeHTTP(w, r)\n}\n\n// chain builds a http.Handler composed of an inline middleware stack and endpoint\n// handler in the order they are passed.\nfunc chain(middlewares []func(http.Handler) http.Handler, endpoint http.Handler) http.Handler {\n\t// Return ahead of time if there aren't any middlewares for the chain\n\tif len(middlewares) == 0 {\n\t\treturn endpoint\n\t}\n\n\t// Wrap the end handler with the middleware chain\n\th := middlewares[len(middlewares)-1](endpoint)\n\tfor i := len(middlewares) - 2; i >= 0; i-- {\n\t\th = middlewares[i](h)\n\t}\n\n\treturn h\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/chi.go",
"content": "// Package chi is a small, idiomatic and composable router for building HTTP services.\n//\n// chi requires Go 1.14 or newer.\n//\n// Example:\n//\n//\tpackage main\n//\n//\timport (\n//\t\t\"net/http\"\n//\n//\t\t\"github.com/go-chi/chi/v5\"\n//\t\t\"github.com/go-chi/chi/v5/middleware\"\n//\t)\n//\n//\tfunc main() {\n//\t\tr := chi.NewRouter()\n//\t\tr.Use(middleware.Logger)\n//\t\tr.Use(middleware.Recoverer)\n//\n//\t\tr.Get(\"/\", func(w http.ResponseWriter, r *http.Request) {\n//\t\t\tw.Write([]byte(\"root.\"))\n//\t\t})\n//\n//\t\thttp.ListenAndServe(\":3333\", r)\n//\t}\n//\n// See github.com/go-chi/chi/_examples/ for more in-depth examples.\n//\n// URL patterns allow for easy matching of path components in HTTP\n// requests. The matching components can then be accessed using\n// chi.URLParam(). All patterns must begin with a slash.\n//\n// A simple named placeholder {name} matches any sequence of characters\n// up to the next / or the end of the URL. Trailing slashes on paths must\n// be handled explicitly.\n//\n// A placeholder with a name followed by a colon allows a regular\n// expression match, for example {number:\\\\d+}. The regular expression\n// syntax is Go's normal regexp RE2 syntax, except that regular expressions\n// including { or } are not supported, and / will never be\n// matched. An anonymous regexp pattern is allowed, using an empty string\n// before the colon in the placeholder, such as {:\\\\d+}\n//\n// The special placeholder of asterisk matches the rest of the requested\n// URL. Any trailing characters in the pattern are ignored. This is the only\n// placeholder which will match / characters.\n//\n// Examples:\n//\n//\t\"/user/{name}\" matches \"/user/jsmith\" but not \"/user/jsmith/info\" or \"/user/jsmith/\"\n//\t\"/user/{name}/info\" matches \"/user/jsmith/info\"\n//\t\"/page/*\" matches \"/page/intro/latest\"\n//\t\"/page/{other}/index\" also matches \"/page/intro/latest\"\n//\t\"/date/{yyyy:\\\\d\\\\d\\\\d\\\\d}/{mm:\\\\d\\\\d}/{dd:\\\\d\\\\d}\" matches \"/date/2017/04/01\"\npackage chi\n\nimport \"net/http\"\n\n// NewRouter returns a new Mux object that implements the Router interface.\nfunc NewRouter() *Mux {\n\treturn NewMux()\n}\n\n// Router consisting of the core routing methods used by chi's Mux,\n// using only the standard net/http.\ntype Router interface {\n\thttp.Handler\n\tRoutes\n\n\t// Use appends one or more middlewares onto the Router stack.\n\tUse(middlewares ...func(http.Handler) http.Handler)\n\n\t// With adds inline middlewares for an endpoint handler.\n\tWith(middlewares ...func(http.Handler) http.Handler) Router\n\n\t// Group adds a new inline-Router along the current routing\n\t// path, with a fresh middleware stack for the inline-Router.\n\tGroup(fn func(r Router)) Router\n\n\t// Route mounts a sub-Router along a `pattern`` string.\n\tRoute(pattern string, fn func(r Router)) Router\n\n\t// Mount attaches another http.Handler along ./pattern/*\n\tMount(pattern string, h http.Handler)\n\n\t// Handle and HandleFunc adds routes for `pattern` that matches\n\t// all HTTP methods.\n\tHandle(pattern string, h http.Handler)\n\tHandleFunc(pattern string, h http.HandlerFunc)\n\n\t// Method and MethodFunc adds routes for `pattern` that matches\n\t// the `method` HTTP method.\n\tMethod(method, pattern string, h http.Handler)\n\tMethodFunc(method, pattern string, h http.HandlerFunc)\n\n\t// HTTP-method routing along `pattern`\n\tConnect(pattern string, h http.HandlerFunc)\n\tDelete(pattern string, h http.HandlerFunc)\n\tGet(pattern string, h http.HandlerFunc)\n\tHead(pattern string, h http.HandlerFunc)\n\tOptions(pattern string, h http.HandlerFunc)\n\tPatch(pattern string, h http.HandlerFunc)\n\tPost(pattern string, h http.HandlerFunc)\n\tPut(pattern string, h http.HandlerFunc)\n\tTrace(pattern string, h http.HandlerFunc)\n\n\t// NotFound defines a handler to respond whenever a route could\n\t// not be found.\n\tNotFound(h http.HandlerFunc)\n\n\t// MethodNotAllowed defines a handler to respond whenever a method is\n\t// not allowed.\n\tMethodNotAllowed(h http.HandlerFunc)\n}\n\n// Routes interface adds two methods for router traversal, which is also\n// used by the `docgen` subpackage to generation documentation for Routers.\ntype Routes interface {\n\t// Routes returns the routing tree in an easily traversable structure.\n\tRoutes() []Route\n\n\t// Middlewares returns the list of middlewares in use by the router.\n\tMiddlewares() Middlewares\n\n\t// Match searches the routing tree for a handler that matches\n\t// the method/path - similar to routing a http request, but without\n\t// executing the handler thereafter.\n\tMatch(rctx *Context, method, path string) bool\n}\n\n// Middlewares type is a slice of standard middleware handlers with methods\n// to compose middleware chains and http.Handler's.\ntype Middlewares []func(http.Handler) http.Handler\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/context.go",
"content": "package chi\n\nimport (\n\t\"context\"\n\t\"net/http\"\n\t\"strings\"\n)\n\n// URLParam returns the url parameter from a http.Request object.\nfunc URLParam(r *http.Request, key string) string {\n\tif rctx := RouteContext(r.Context()); rctx != nil {\n\t\treturn rctx.URLParam(key)\n\t}\n\treturn \"\"\n}\n\n// URLParamFromCtx returns the url parameter from a http.Request Context.\nfunc URLParamFromCtx(ctx context.Context, key string) string {\n\tif rctx := RouteContext(ctx); rctx != nil {\n\t\treturn rctx.URLParam(key)\n\t}\n\treturn \"\"\n}\n\n// RouteContext returns chi's routing Context object from a\n// http.Request Context.\nfunc RouteContext(ctx context.Context) *Context {\n\tval, _ := ctx.Value(RouteCtxKey).(*Context)\n\treturn val\n}\n\n// NewRouteContext returns a new routing Context object.\nfunc NewRouteContext() *Context {\n\treturn &Context{}\n}\n\nvar (\n\t// RouteCtxKey is the context.Context key to store the request context.\n\tRouteCtxKey = &contextKey{\"RouteContext\"}\n)\n\n// Context is the default routing context set on the root node of a\n// request context to track route patterns, URL parameters and\n// an optional routing path.\ntype Context struct {\n\tRoutes Routes\n\n\t// parentCtx is the parent of this one, for using Context as a\n\t// context.Context directly. This is an optimization that saves\n\t// 1 allocation.\n\tparentCtx context.Context\n\n\t// Routing path/method override used during the route search.\n\t// See Mux#routeHTTP method.\n\tRoutePath string\n\tRouteMethod string\n\n\t// URLParams are the stack of routeParams captured during the\n\t// routing lifecycle across a stack of sub-routers.\n\tURLParams RouteParams\n\n\t// Route parameters matched for the current sub-router. It is\n\t// intentionally unexported so it can't be tampered.\n\trouteParams RouteParams\n\n\t// The endpoint routing pattern that matched the request URI path\n\t// or `RoutePath` of the current sub-router. This value will update\n\t// during the lifecycle of a request passing through a stack of\n\t// sub-routers.\n\troutePattern string\n\n\t// Routing pattern stack throughout the lifecycle of the request,\n\t// across all connected routers. It is a record of all matching\n\t// patterns across a stack of sub-routers.\n\tRoutePatterns []string\n\n\t// methodNotAllowed hint\n\tmethodNotAllowed bool\n\tmethodsAllowed []methodTyp // allowed methods in case of a 405\n}\n\n// Reset a routing context to its initial state.\nfunc (x *Context) Reset() {\n\tx.Routes = nil\n\tx.RoutePath = \"\"\n\tx.RouteMethod = \"\"\n\tx.RoutePatterns = x.RoutePatterns[:0]\n\tx.URLParams.Keys = x.URLParams.Keys[:0]\n\tx.URLParams.Values = x.URLParams.Values[:0]\n\n\tx.routePattern = \"\"\n\tx.routeParams.Keys = x.routeParams.Keys[:0]\n\tx.routeParams.Values = x.routeParams.Values[:0]\n\tx.methodNotAllowed = false\n\tx.methodsAllowed = x.methodsAllowed[:0]\n\tx.parentCtx = nil\n}\n\n// URLParam returns the corresponding URL parameter value from the request\n// routing context.\nfunc (x *Context) URLParam(key string) string {\n\tfor k := len(x.URLParams.Keys) - 1; k >= 0; k-- {\n\t\tif x.URLParams.Keys[k] == key {\n\t\t\treturn x.URLParams.Values[k]\n\t\t}\n\t}\n\treturn \"\"\n}\n\n// RoutePattern builds the routing pattern string for the particular\n// request, at the particular point during routing. This means, the value\n// will change throughout the execution of a request in a router. That is\n// why its advised to only use this value after calling the next handler.\n//\n// For example,\n//\n//\tfunc Instrument(next http.Handler) http.Handler {\n//\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n//\t\t\tnext.ServeHTTP(w, r)\n//\t\t\troutePattern := chi.RouteContext(r.Context()).RoutePattern()\n//\t\t\tmeasure(w, r, routePattern)\n//\t\t})\n//\t}\nfunc (x *Context) RoutePattern() string {\n\troutePattern := strings.Join(x.RoutePatterns, \"\")\n\troutePattern = replaceWildcards(routePattern)\n\tif routePattern != \"/\" {\n\t\troutePattern = strings.TrimSuffix(routePattern, \"//\")\n\t\troutePattern = strings.TrimSuffix(routePattern, \"/\")\n\t}\n\treturn routePattern\n}\n\n// replaceWildcards takes a route pattern and recursively replaces all\n// occurrences of \"/*/\" to \"/\".\nfunc replaceWildcards(p string) string {\n\tif strings.Contains(p, \"/*/\") {\n\t\treturn replaceWildcards(strings.Replace(p, \"/*/\", \"/\", -1))\n\t}\n\treturn p\n}\n\n// RouteParams is a structure to track URL routing parameters efficiently.\ntype RouteParams struct {\n\tKeys, Values []string\n}\n\n// Add will append a URL parameter to the end of the route param\nfunc (s *RouteParams) Add(key, value string) {\n\ts.Keys = append(s.Keys, key)\n\ts.Values = append(s.Values, value)\n}\n\n// contextKey is a value for use with context.WithValue. It's used as\n// a pointer so it fits in an interface{} without allocation. This technique\n// for defining context keys was copied from Go 1.7's new use of context in net/http.\ntype contextKey struct {\n\tname string\n}\n\nfunc (k *contextKey) String() string {\n\treturn \"chi context value \" + k.name\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/basic_auth.go",
"content": "package middleware\n\nimport (\n\t\"crypto/subtle\"\n\t\"fmt\"\n\t\"net/http\"\n)\n\n// BasicAuth implements a simple middleware handler for adding basic http auth to a route.\nfunc BasicAuth(realm string, creds map[string]string) func(next http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\tuser, pass, ok := r.BasicAuth()\n\t\t\tif !ok {\n\t\t\t\tbasicAuthFailed(w, realm)\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tcredPass, credUserOk := creds[user]\n\t\t\tif !credUserOk || subtle.ConstantTimeCompare([]byte(pass), []byte(credPass)) != 1 {\n\t\t\t\tbasicAuthFailed(w, realm)\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tnext.ServeHTTP(w, r)\n\t\t})\n\t}\n}\n\nfunc basicAuthFailed(w http.ResponseWriter, realm string) {\n\tw.Header().Add(\"WWW-Authenticate\", fmt.Sprintf(`Basic realm=\"%s\"`, realm))\n\tw.WriteHeader(http.StatusUnauthorized)\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/clean_path.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"path\"\n\n\t\"github.com/go-chi/chi/v5\"\n)\n\n// CleanPath middleware will clean out double slash mistakes from a user's request path.\n// For example, if a user requests /users//1 or //users////1 will both be treated as: /users/1\nfunc CleanPath(next http.Handler) http.Handler {\n\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\trctx := chi.RouteContext(r.Context())\n\n\t\troutePath := rctx.RoutePath\n\t\tif routePath == \"\" {\n\t\t\tif r.URL.RawPath != \"\" {\n\t\t\t\troutePath = r.URL.RawPath\n\t\t\t} else {\n\t\t\t\troutePath = r.URL.Path\n\t\t\t}\n\t\t\trctx.RoutePath = path.Clean(routePath)\n\t\t}\n\n\t\tnext.ServeHTTP(w, r)\n\t})\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/compress.go",
"content": "package middleware\n\nimport (\n\t\"bufio\"\n\t\"compress/flate\"\n\t\"compress/gzip\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"io/ioutil\"\n\t\"net\"\n\t\"net/http\"\n\t\"strings\"\n\t\"sync\"\n)\n\nvar defaultCompressibleContentTypes = []string{\n\t\"text/html\",\n\t\"text/css\",\n\t\"text/plain\",\n\t\"text/javascript\",\n\t\"application/javascript\",\n\t\"application/x-javascript\",\n\t\"application/json\",\n\t\"application/atom+xml\",\n\t\"application/rss+xml\",\n\t\"image/svg+xml\",\n}\n\n// Compress is a middleware that compresses response\n// body of a given content types to a data format based\n// on Accept-Encoding request header. It uses a given\n// compression level.\n//\n// NOTE: make sure to set the Content-Type header on your response\n// otherwise this middleware will not compress the response body. For ex, in\n// your handler you should set w.Header().Set(\"Content-Type\", http.DetectContentType(yourBody))\n// or set it manually.\n//\n// Passing a compression level of 5 is sensible value\nfunc Compress(level int, types ...string) func(next http.Handler) http.Handler {\n\tcompressor := NewCompressor(level, types...)\n\treturn compressor.Handler\n}\n\n// Compressor represents a set of encoding configurations.\ntype Compressor struct {\n\t// The mapping of encoder names to encoder functions.\n\tencoders map[string]EncoderFunc\n\t// The mapping of pooled encoders to pools.\n\tpooledEncoders map[string]*sync.Pool\n\t// The set of content types allowed to be compressed.\n\tallowedTypes map[string]struct{}\n\tallowedWildcards map[string]struct{}\n\t// The list of encoders in order of decreasing precedence.\n\tencodingPrecedence []string\n\tlevel int // The compression level.\n}\n\n// NewCompressor creates a new Compressor that will handle encoding responses.\n//\n// The level should be one of the ones defined in the flate package.\n// The types are the content types that are allowed to be compressed.\nfunc NewCompressor(level int, types ...string) *Compressor {\n\t// If types are provided, set those as the allowed types. If none are\n\t// provided, use the default list.\n\tallowedTypes := make(map[string]struct{})\n\tallowedWildcards := make(map[string]struct{})\n\tif len(types) > 0 {\n\t\tfor _, t := range types {\n\t\t\tif strings.Contains(strings.TrimSuffix(t, \"/*\"), \"*\") {\n\t\t\t\tpanic(fmt.Sprintf(\"middleware/compress: Unsupported content-type wildcard pattern '%s'. Only '/*' supported\", t))\n\t\t\t}\n\t\t\tif strings.HasSuffix(t, \"/*\") {\n\t\t\t\tallowedWildcards[strings.TrimSuffix(t, \"/*\")] = struct{}{}\n\t\t\t} else {\n\t\t\t\tallowedTypes[t] = struct{}{}\n\t\t\t}\n\t\t}\n\t} else {\n\t\tfor _, t := range defaultCompressibleContentTypes {\n\t\t\tallowedTypes[t] = struct{}{}\n\t\t}\n\t}\n\n\tc := &Compressor{\n\t\tlevel: level,\n\t\tencoders: make(map[string]EncoderFunc),\n\t\tpooledEncoders: make(map[string]*sync.Pool),\n\t\tallowedTypes: allowedTypes,\n\t\tallowedWildcards: allowedWildcards,\n\t}\n\n\t// Set the default encoders. The precedence order uses the reverse\n\t// ordering that the encoders were added. This means adding new encoders\n\t// will move them to the front of the order.\n\t//\n\t// TODO:\n\t// lzma: Opera.\n\t// sdch: Chrome, Android. Gzip output + dictionary header.\n\t// br: Brotli, see https://github.com/go-chi/chi/pull/326\n\n\t// HTTP 1.1 \"deflate\" (RFC 2616) stands for DEFLATE data (RFC 1951)\n\t// wrapped with zlib (RFC 1950). The zlib wrapper uses Adler-32\n\t// checksum compared to CRC-32 used in \"gzip\" and thus is faster.\n\t//\n\t// But.. some old browsers (MSIE, Safari 5.1) incorrectly expect\n\t// raw DEFLATE data only, without the mentioned zlib wrapper.\n\t// Because of this major confusion, most modern browsers try it\n\t// both ways, first looking for zlib headers.\n\t// Quote by Mark Adler: http://stackoverflow.com/a/9186091/385548\n\t//\n\t// The list of browsers having problems is quite big, see:\n\t// http://zoompf.com/blog/2012/02/lose-the-wait-http-compression\n\t// https://web.archive.org/web/20120321182910/http://www.vervestudios.co/projects/compression-tests/results\n\t//\n\t// That's why we prefer gzip over deflate. It's just more reliable\n\t// and not significantly slower than deflate.\n\tc.SetEncoder(\"deflate\", encoderDeflate)\n\n\t// TODO: Exception for old MSIE browsers that can't handle non-HTML?\n\t// https://zoompf.com/blog/2012/02/lose-the-wait-http-compression\n\tc.SetEncoder(\"gzip\", encoderGzip)\n\n\t// NOTE: Not implemented, intentionally:\n\t// case \"compress\": // LZW. Deprecated.\n\t// case \"bzip2\": // Too slow on-the-fly.\n\t// case \"zopfli\": // Too slow on-the-fly.\n\t// case \"xz\": // Too slow on-the-fly.\n\treturn c\n}\n\n// SetEncoder can be used to set the implementation of a compression algorithm.\n//\n// The encoding should be a standardised identifier. See:\n// https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding\n//\n// For example, add the Brotli algorithm:\n//\n//\timport brotli_enc \"gopkg.in/kothar/brotli-go.v0/enc\"\n//\n//\tcompressor := middleware.NewCompressor(5, \"text/html\")\n//\tcompressor.SetEncoder(\"br\", func(w io.Writer, level int) io.Writer {\n//\t\tparams := brotli_enc.NewBrotliParams()\n//\t\tparams.SetQuality(level)\n//\t\treturn brotli_enc.NewBrotliWriter(params, w)\n//\t})\nfunc (c *Compressor) SetEncoder(encoding string, fn EncoderFunc) {\n\tencoding = strings.ToLower(encoding)\n\tif encoding == \"\" {\n\t\tpanic(\"the encoding can not be empty\")\n\t}\n\tif fn == nil {\n\t\tpanic(\"attempted to set a nil encoder function\")\n\t}\n\n\t// If we are adding a new encoder that is already registered, we have to\n\t// clear that one out first.\n\tdelete(c.pooledEncoders, encoding)\n\tdelete(c.encoders, encoding)\n\n\t// If the encoder supports Resetting (IoReseterWriter), then it can be pooled.\n\tencoder := fn(ioutil.Discard, c.level)\n\tif encoder != nil {\n\t\tif _, ok := encoder.(ioResetterWriter); ok {\n\t\t\tpool := &sync.Pool{\n\t\t\t\tNew: func() interface{} {\n\t\t\t\t\treturn fn(ioutil.Discard, c.level)\n\t\t\t\t},\n\t\t\t}\n\t\t\tc.pooledEncoders[encoding] = pool\n\t\t}\n\t}\n\t// If the encoder is not in the pooledEncoders, add it to the normal encoders.\n\tif _, ok := c.pooledEncoders[encoding]; !ok {\n\t\tc.encoders[encoding] = fn\n\t}\n\n\tfor i, v := range c.encodingPrecedence {\n\t\tif v == encoding {\n\t\t\tc.encodingPrecedence = append(c.encodingPrecedence[:i], c.encodingPrecedence[i+1:]...)\n\t\t}\n\t}\n\n\tc.encodingPrecedence = append([]string{encoding}, c.encodingPrecedence...)\n}\n\n// Handler returns a new middleware that will compress the response based on the\n// current Compressor.\nfunc (c *Compressor) Handler(next http.Handler) http.Handler {\n\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\tencoder, encoding, cleanup := c.selectEncoder(r.Header, w)\n\n\t\tcw := &compressResponseWriter{\n\t\t\tResponseWriter: w,\n\t\t\tw: w,\n\t\t\tcontentTypes: c.allowedTypes,\n\t\t\tcontentWildcards: c.allowedWildcards,\n\t\t\tencoding: encoding,\n\t\t\tcompressible: false, // determined in post-handler\n\t\t}\n\t\tif encoder != nil {\n\t\t\tcw.w = encoder\n\t\t}\n\t\t// Re-add the encoder to the pool if applicable.\n\t\tdefer cleanup()\n\t\tdefer cw.Close()\n\n\t\tnext.ServeHTTP(cw, r)\n\t})\n}\n\n// selectEncoder returns the encoder, the name of the encoder, and a closer function.\nfunc (c *Compressor) selectEncoder(h http.Header, w io.Writer) (io.Writer, string, func()) {\n\theader := h.Get(\"Accept-Encoding\")\n\n\t// Parse the names of all accepted algorithms from the header.\n\taccepted := strings.Split(strings.ToLower(header), \",\")\n\n\t// Find supported encoder by accepted list by precedence\n\tfor _, name := range c.encodingPrecedence {\n\t\tif matchAcceptEncoding(accepted, name) {\n\t\t\tif pool, ok := c.pooledEncoders[name]; ok {\n\t\t\t\tencoder := pool.Get().(ioResetterWriter)\n\t\t\t\tcleanup := func() {\n\t\t\t\t\tpool.Put(encoder)\n\t\t\t\t}\n\t\t\t\tencoder.Reset(w)\n\t\t\t\treturn encoder, name, cleanup\n\n\t\t\t}\n\t\t\tif fn, ok := c.encoders[name]; ok {\n\t\t\t\treturn fn(w, c.level), name, func() {}\n\t\t\t}\n\t\t}\n\n\t}\n\n\t// No encoder found to match the accepted encoding\n\treturn nil, \"\", func() {}\n}\n\nfunc matchAcceptEncoding(accepted []string, encoding string) bool {\n\tfor _, v := range accepted {\n\t\tif strings.Contains(v, encoding) {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\n// An EncoderFunc is a function that wraps the provided io.Writer with a\n// streaming compression algorithm and returns it.\n//\n// In case of failure, the function should return nil.\ntype EncoderFunc func(w io.Writer, level int) io.Writer\n\n// Interface for types that allow resetting io.Writers.\ntype ioResetterWriter interface {\n\tio.Writer\n\tReset(w io.Writer)\n}\n\ntype compressResponseWriter struct {\n\thttp.ResponseWriter\n\n\t// The streaming encoder writer to be used if there is one. Otherwise,\n\t// this is just the normal writer.\n\tw io.Writer\n\tcontentTypes map[string]struct{}\n\tcontentWildcards map[string]struct{}\n\tencoding string\n\twroteHeader bool\n\tcompressible bool\n}\n\nfunc (cw *compressResponseWriter) isCompressible() bool {\n\t// Parse the first part of the Content-Type response header.\n\tcontentType := cw.Header().Get(\"Content-Type\")\n\tif idx := strings.Index(contentType, \";\"); idx >= 0 {\n\t\tcontentType = contentType[0:idx]\n\t}\n\n\t// Is the content type compressible?\n\tif _, ok := cw.contentTypes[contentType]; ok {\n\t\treturn true\n\t}\n\tif idx := strings.Index(contentType, \"/\"); idx > 0 {\n\t\tcontentType = contentType[0:idx]\n\t\t_, ok := cw.contentWildcards[contentType]\n\t\treturn ok\n\t}\n\treturn false\n}\n\nfunc (cw *compressResponseWriter) WriteHeader(code int) {\n\tif cw.wroteHeader {\n\t\tcw.ResponseWriter.WriteHeader(code) // Allow multiple calls to propagate.\n\t\treturn\n\t}\n\tcw.wroteHeader = true\n\tdefer cw.ResponseWriter.WriteHeader(code)\n\n\t// Already compressed data?\n\tif cw.Header().Get(\"Content-Encoding\") != \"\" {\n\t\treturn\n\t}\n\n\tif !cw.isCompressible() {\n\t\tcw.compressible = false\n\t\treturn\n\t}\n\n\tif cw.encoding != \"\" {\n\t\tcw.compressible = true\n\t\tcw.Header().Set(\"Content-Encoding\", cw.encoding)\n\t\tcw.Header().Add(\"Vary\", \"Accept-Encoding\")\n\n\t\t// The content-length after compression is unknown\n\t\tcw.Header().Del(\"Content-Length\")\n\t}\n}\n\nfunc (cw *compressResponseWriter) Write(p []byte) (int, error) {\n\tif !cw.wroteHeader {\n\t\tcw.WriteHeader(http.StatusOK)\n\t}\n\n\treturn cw.writer().Write(p)\n}\n\nfunc (cw *compressResponseWriter) writer() io.Writer {\n\tif cw.compressible {\n\t\treturn cw.w\n\t}\n\treturn cw.ResponseWriter\n}\n\ntype compressFlusher interface {\n\tFlush() error\n}\n\nfunc (cw *compressResponseWriter) Flush() {\n\tif f, ok := cw.writer().(http.Flusher); ok {\n\t\tf.Flush()\n\t}\n\t// If the underlying writer has a compression flush signature,\n\t// call this Flush() method instead\n\tif f, ok := cw.writer().(compressFlusher); ok {\n\t\tf.Flush()\n\n\t\t// Also flush the underlying response writer\n\t\tif f, ok := cw.ResponseWriter.(http.Flusher); ok {\n\t\t\tf.Flush()\n\t\t}\n\t}\n}\n\nfunc (cw *compressResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {\n\tif hj, ok := cw.writer().(http.Hijacker); ok {\n\t\treturn hj.Hijack()\n\t}\n\treturn nil, nil, errors.New(\"chi/middleware: http.Hijacker is unavailable on the writer\")\n}\n\nfunc (cw *compressResponseWriter) Push(target string, opts *http.PushOptions) error {\n\tif ps, ok := cw.writer().(http.Pusher); ok {\n\t\treturn ps.Push(target, opts)\n\t}\n\treturn errors.New(\"chi/middleware: http.Pusher is unavailable on the writer\")\n}\n\nfunc (cw *compressResponseWriter) Close() error {\n\tif c, ok := cw.writer().(io.WriteCloser); ok {\n\t\treturn c.Close()\n\t}\n\treturn errors.New(\"chi/middleware: io.WriteCloser is unavailable on the writer\")\n}\n\nfunc (cw *compressResponseWriter) Unwrap() http.ResponseWriter {\n\treturn cw.ResponseWriter\n}\n\nfunc encoderGzip(w io.Writer, level int) io.Writer {\n\tgw, err := gzip.NewWriterLevel(w, level)\n\tif err != nil {\n\t\treturn nil\n\t}\n\treturn gw\n}\n\nfunc encoderDeflate(w io.Writer, level int) io.Writer {\n\tdw, err := flate.NewWriter(w, level)\n\tif err != nil {\n\t\treturn nil\n\t}\n\treturn dw\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/content_charset.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"strings\"\n)\n\n// ContentCharset generates a handler that writes a 415 Unsupported Media Type response if none of the charsets match.\n// An empty charset will allow requests with no Content-Type header or no specified charset.\nfunc ContentCharset(charsets ...string) func(next http.Handler) http.Handler {\n\tfor i, c := range charsets {\n\t\tcharsets[i] = strings.ToLower(c)\n\t}\n\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\tif !contentEncoding(r.Header.Get(\"Content-Type\"), charsets...) {\n\t\t\t\tw.WriteHeader(http.StatusUnsupportedMediaType)\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tnext.ServeHTTP(w, r)\n\t\t})\n\t}\n}\n\n// Check the content encoding against a list of acceptable values.\nfunc contentEncoding(ce string, charsets ...string) bool {\n\t_, ce = split(strings.ToLower(ce), \";\")\n\t_, ce = split(ce, \"charset=\")\n\tce, _ = split(ce, \";\")\n\tfor _, c := range charsets {\n\t\tif ce == c {\n\t\t\treturn true\n\t\t}\n\t}\n\n\treturn false\n}\n\n// Split a string in two parts, cleaning any whitespace.\nfunc split(str, sep string) (string, string) {\n\tvar a, b string\n\tvar parts = strings.SplitN(str, sep, 2)\n\ta = strings.TrimSpace(parts[0])\n\tif len(parts) == 2 {\n\t\tb = strings.TrimSpace(parts[1])\n\t}\n\n\treturn a, b\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/content_encoding.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"strings\"\n)\n\n// AllowContentEncoding enforces a whitelist of request Content-Encoding otherwise responds\n// with a 415 Unsupported Media Type status.\nfunc AllowContentEncoding(contentEncoding ...string) func(next http.Handler) http.Handler {\n\tallowedEncodings := make(map[string]struct{}, len(contentEncoding))\n\tfor _, encoding := range contentEncoding {\n\t\tallowedEncodings[strings.TrimSpace(strings.ToLower(encoding))] = struct{}{}\n\t}\n\treturn func(next http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\trequestEncodings := r.Header[\"Content-Encoding\"]\n\t\t\t// skip check for empty content body or no Content-Encoding\n\t\t\tif r.ContentLength == 0 {\n\t\t\t\tnext.ServeHTTP(w, r)\n\t\t\t\treturn\n\t\t\t}\n\t\t\t// All encodings in the request must be allowed\n\t\t\tfor _, encoding := range requestEncodings {\n\t\t\t\tif _, ok := allowedEncodings[strings.TrimSpace(strings.ToLower(encoding))]; !ok {\n\t\t\t\t\tw.WriteHeader(http.StatusUnsupportedMediaType)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t\tnext.ServeHTTP(w, r)\n\t\t}\n\t\treturn http.HandlerFunc(fn)\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/content_type.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"strings\"\n)\n\n// SetHeader is a convenience handler to set a response header key/value\nfunc SetHeader(key, value string) func(next http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\tw.Header().Set(key, value)\n\t\t\tnext.ServeHTTP(w, r)\n\t\t}\n\t\treturn http.HandlerFunc(fn)\n\t}\n}\n\n// AllowContentType enforces a whitelist of request Content-Types otherwise responds\n// with a 415 Unsupported Media Type status.\nfunc AllowContentType(contentTypes ...string) func(next http.Handler) http.Handler {\n\tallowedContentTypes := make(map[string]struct{}, len(contentTypes))\n\tfor _, ctype := range contentTypes {\n\t\tallowedContentTypes[strings.TrimSpace(strings.ToLower(ctype))] = struct{}{}\n\t}\n\n\treturn func(next http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\tif r.ContentLength == 0 {\n\t\t\t\t// skip check for empty content body\n\t\t\t\tnext.ServeHTTP(w, r)\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\ts := strings.ToLower(strings.TrimSpace(r.Header.Get(\"Content-Type\")))\n\t\t\tif i := strings.Index(s, \";\"); i > -1 {\n\t\t\t\ts = s[0:i]\n\t\t\t}\n\n\t\t\tif _, ok := allowedContentTypes[s]; ok {\n\t\t\t\tnext.ServeHTTP(w, r)\n\t\t\t\treturn\n\t\t\t}\n\n\t\t\tw.WriteHeader(http.StatusUnsupportedMediaType)\n\t\t}\n\t\treturn http.HandlerFunc(fn)\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/get_head.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/go-chi/chi/v5\"\n)\n\n// GetHead automatically route undefined HEAD requests to GET handlers.\nfunc GetHead(next http.Handler) http.Handler {\n\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\tif r.Method == \"HEAD\" {\n\t\t\trctx := chi.RouteContext(r.Context())\n\t\t\troutePath := rctx.RoutePath\n\t\t\tif routePath == \"\" {\n\t\t\t\tif r.URL.RawPath != \"\" {\n\t\t\t\t\troutePath = r.URL.RawPath\n\t\t\t\t} else {\n\t\t\t\t\troutePath = r.URL.Path\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Temporary routing context to look-ahead before routing the request\n\t\t\ttctx := chi.NewRouteContext()\n\n\t\t\t// Attempt to find a HEAD handler for the routing path, if not found, traverse\n\t\t\t// the router as through its a GET route, but proceed with the request\n\t\t\t// with the HEAD method.\n\t\t\tif !rctx.Routes.Match(tctx, \"HEAD\", routePath) {\n\t\t\t\trctx.RouteMethod = \"GET\"\n\t\t\t\trctx.RoutePath = routePath\n\t\t\t\tnext.ServeHTTP(w, r)\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\n\t\tnext.ServeHTTP(w, r)\n\t})\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/heartbeat.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"strings\"\n)\n\n// Heartbeat endpoint middleware useful to setting up a path like\n// `/ping` that load balancers or uptime testing external services\n// can make a request before hitting any routes. It's also convenient\n// to place this above ACL middlewares as well.\nfunc Heartbeat(endpoint string) func(http.Handler) http.Handler {\n\tf := func(h http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\tif (r.Method == \"GET\" || r.Method == \"HEAD\") && strings.EqualFold(r.URL.Path, endpoint) {\n\t\t\t\tw.Header().Set(\"Content-Type\", \"text/plain\")\n\t\t\t\tw.WriteHeader(http.StatusOK)\n\t\t\t\tw.Write([]byte(\".\"))\n\t\t\t\treturn\n\t\t\t}\n\t\t\th.ServeHTTP(w, r)\n\t\t}\n\t\treturn http.HandlerFunc(fn)\n\t}\n\treturn f\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/logger.go",
"content": "package middleware\n\nimport (\n\t\"bytes\"\n\t\"context\"\n\t\"log\"\n\t\"net/http\"\n\t\"os\"\n\t\"runtime\"\n\t\"time\"\n)\n\nvar (\n\t// LogEntryCtxKey is the context.Context key to store the request log entry.\n\tLogEntryCtxKey = &contextKey{\"LogEntry\"}\n\n\t// DefaultLogger is called by the Logger middleware handler to log each request.\n\t// Its made a package-level variable so that it can be reconfigured for custom\n\t// logging configurations.\n\tDefaultLogger func(next http.Handler) http.Handler\n)\n\n// Logger is a middleware that logs the start and end of each request, along\n// with some useful data about what was requested, what the response status was,\n// and how long it took to return. When standard output is a TTY, Logger will\n// print in color, otherwise it will print in black and white. Logger prints a\n// request ID if one is provided.\n//\n// Alternatively, look at https://github.com/goware/httplog for a more in-depth\n// http logger with structured logging support.\n//\n// IMPORTANT NOTE: Logger should go before any other middleware that may change\n// the response, such as middleware.Recoverer. Example:\n//\n//\tr := chi.NewRouter()\n//\tr.Use(middleware.Logger) // <--<< Logger should come before Recoverer\n//\tr.Use(middleware.Recoverer)\n//\tr.Get(\"/\", handler)\nfunc Logger(next http.Handler) http.Handler {\n\treturn DefaultLogger(next)\n}\n\n// RequestLogger returns a logger handler using a custom LogFormatter.\nfunc RequestLogger(f LogFormatter) func(next http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\tentry := f.NewLogEntry(r)\n\t\t\tww := NewWrapResponseWriter(w, r.ProtoMajor)\n\n\t\t\tt1 := time.Now()\n\t\t\tdefer func() {\n\t\t\t\tentry.Write(ww.Status(), ww.BytesWritten(), ww.Header(), time.Since(t1), nil)\n\t\t\t}()\n\n\t\t\tnext.ServeHTTP(ww, WithLogEntry(r, entry))\n\t\t}\n\t\treturn http.HandlerFunc(fn)\n\t}\n}\n\n// LogFormatter initiates the beginning of a new LogEntry per request.\n// See DefaultLogFormatter for an example implementation.\ntype LogFormatter interface {\n\tNewLogEntry(r *http.Request) LogEntry\n}\n\n// LogEntry records the final log when a request completes.\n// See defaultLogEntry for an example implementation.\ntype LogEntry interface {\n\tWrite(status, bytes int, header http.Header, elapsed time.Duration, extra interface{})\n\tPanic(v interface{}, stack []byte)\n}\n\n// GetLogEntry returns the in-context LogEntry for a request.\nfunc GetLogEntry(r *http.Request) LogEntry {\n\tentry, _ := r.Context().Value(LogEntryCtxKey).(LogEntry)\n\treturn entry\n}\n\n// WithLogEntry sets the in-context LogEntry for a request.\nfunc WithLogEntry(r *http.Request, entry LogEntry) *http.Request {\n\tr = r.WithContext(context.WithValue(r.Context(), LogEntryCtxKey, entry))\n\treturn r\n}\n\n// LoggerInterface accepts printing to stdlib logger or compatible logger.\ntype LoggerInterface interface {\n\tPrint(v ...interface{})\n}\n\n// DefaultLogFormatter is a simple logger that implements a LogFormatter.\ntype DefaultLogFormatter struct {\n\tLogger LoggerInterface\n\tNoColor bool\n}\n\n// NewLogEntry creates a new LogEntry for the request.\nfunc (l *DefaultLogFormatter) NewLogEntry(r *http.Request) LogEntry {\n\tuseColor := !l.NoColor\n\tentry := &defaultLogEntry{\n\t\tDefaultLogFormatter: l,\n\t\trequest: r,\n\t\tbuf: &bytes.Buffer{},\n\t\tuseColor: useColor,\n\t}\n\n\treqID := GetReqID(r.Context())\n\tif reqID != \"\" {\n\t\tcW(entry.buf, useColor, nYellow, \"[%s] \", reqID)\n\t}\n\tcW(entry.buf, useColor, nCyan, \"\\\"\")\n\tcW(entry.buf, useColor, bMagenta, \"%s \", r.Method)\n\n\tscheme := \"http\"\n\tif r.TLS != nil {\n\t\tscheme = \"https\"\n\t}\n\tcW(entry.buf, useColor, nCyan, \"%s://%s%s %s\\\" \", scheme, r.Host, r.RequestURI, r.Proto)\n\n\tentry.buf.WriteString(\"from \")\n\tentry.buf.WriteString(r.RemoteAddr)\n\tentry.buf.WriteString(\" - \")\n\n\treturn entry\n}\n\ntype defaultLogEntry struct {\n\t*DefaultLogFormatter\n\trequest *http.Request\n\tbuf *bytes.Buffer\n\tuseColor bool\n}\n\nfunc (l *defaultLogEntry) Write(status, bytes int, header http.Header, elapsed time.Duration, extra interface{}) {\n\tswitch {\n\tcase status < 200:\n\t\tcW(l.buf, l.useColor, bBlue, \"%03d\", status)\n\tcase status < 300:\n\t\tcW(l.buf, l.useColor, bGreen, \"%03d\", status)\n\tcase status < 400:\n\t\tcW(l.buf, l.useColor, bCyan, \"%03d\", status)\n\tcase status < 500:\n\t\tcW(l.buf, l.useColor, bYellow, \"%03d\", status)\n\tdefault:\n\t\tcW(l.buf, l.useColor, bRed, \"%03d\", status)\n\t}\n\n\tcW(l.buf, l.useColor, bBlue, \" %dB\", bytes)\n\n\tl.buf.WriteString(\" in \")\n\tif elapsed < 500*time.Millisecond {\n\t\tcW(l.buf, l.useColor, nGreen, \"%s\", elapsed)\n\t} else if elapsed < 5*time.Second {\n\t\tcW(l.buf, l.useColor, nYellow, \"%s\", elapsed)\n\t} else {\n\t\tcW(l.buf, l.useColor, nRed, \"%s\", elapsed)\n\t}\n\n\tl.Logger.Print(l.buf.String())\n}\n\nfunc (l *defaultLogEntry) Panic(v interface{}, stack []byte) {\n\tPrintPrettyStack(v)\n}\n\nfunc init() {\n\tcolor := true\n\tif runtime.GOOS == \"windows\" {\n\t\tcolor = false\n\t}\n\tDefaultLogger = RequestLogger(&DefaultLogFormatter{Logger: log.New(os.Stdout, \"\", log.LstdFlags), NoColor: !color})\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/maybe.go",
"content": "package middleware\n\nimport \"net/http\"\n\n// Maybe middleware will allow you to change the flow of the middleware stack execution depending on return\n// value of maybeFn(request). This is useful for example if you'd like to skip a middleware handler if\n// a request does not satisfy the maybeFn logic.\nfunc Maybe(mw func(http.Handler) http.Handler, maybeFn func(r *http.Request) bool) func(http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\tif maybeFn(r) {\n\t\t\t\tmw(next).ServeHTTP(w, r)\n\t\t\t} else {\n\t\t\t\tnext.ServeHTTP(w, r)\n\t\t\t}\n\t\t})\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/middleware.go",
"content": "package middleware\n\nimport \"net/http\"\n\n// New will create a new middleware handler from a http.Handler.\nfunc New(h http.Handler) func(next http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\th.ServeHTTP(w, r)\n\t\t})\n\t}\n}\n\n// contextKey is a value for use with context.WithValue. It's used as\n// a pointer so it fits in an interface{} without allocation. This technique\n// for defining context keys was copied from Go 1.7's new use of context in net/http.\ntype contextKey struct {\n\tname string\n}\n\nfunc (k *contextKey) String() string {\n\treturn \"chi/middleware context value \" + k.name\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/nocache.go",
"content": "package middleware\n\n// Ported from Goji's middleware, source:\n// https://github.com/zenazn/goji/tree/master/web/middleware\n\nimport (\n\t\"net/http\"\n\t\"time\"\n)\n\n// Unix epoch time\nvar epoch = time.Unix(0, 0).UTC().Format(http.TimeFormat)\n\n// Taken from https://github.com/mytrile/nocache\nvar noCacheHeaders = map[string]string{\n\t\"Expires\": epoch,\n\t\"Cache-Control\": \"no-cache, no-store, no-transform, must-revalidate, private, max-age=0\",\n\t\"Pragma\": \"no-cache\",\n\t\"X-Accel-Expires\": \"0\",\n}\n\nvar etagHeaders = []string{\n\t\"ETag\",\n\t\"If-Modified-Since\",\n\t\"If-Match\",\n\t\"If-None-Match\",\n\t\"If-Range\",\n\t\"If-Unmodified-Since\",\n}\n\n// NoCache is a simple piece of middleware that sets a number of HTTP headers to prevent\n// a router (or subrouter) from being cached by an upstream proxy and/or client.\n//\n// As per http://wiki.nginx.org/HttpProxyModule - NoCache sets:\n//\n//\tExpires: Thu, 01 Jan 1970 00:00:00 UTC\n//\tCache-Control: no-cache, private, max-age=0\n//\tX-Accel-Expires: 0\n//\tPragma: no-cache (for HTTP/1.0 proxies/clients)\nfunc NoCache(h http.Handler) http.Handler {\n\tfn := func(w http.ResponseWriter, r *http.Request) {\n\n\t\t// Delete any ETag headers that may have been set\n\t\tfor _, v := range etagHeaders {\n\t\t\tif r.Header.Get(v) != \"\" {\n\t\t\t\tr.Header.Del(v)\n\t\t\t}\n\t\t}\n\n\t\t// Set our NoCache headers\n\t\tfor k, v := range noCacheHeaders {\n\t\t\tw.Header().Set(k, v)\n\t\t}\n\n\t\th.ServeHTTP(w, r)\n\t}\n\n\treturn http.HandlerFunc(fn)\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/page_route.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"strings\"\n)\n\n// PageRoute is a simple middleware which allows you to route a static GET request\n// at the middleware stack level.\nfunc PageRoute(path string, handler http.Handler) func(http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\tif r.Method == \"GET\" && strings.EqualFold(r.URL.Path, path) {\n\t\t\t\thandler.ServeHTTP(w, r)\n\t\t\t\treturn\n\t\t\t}\n\t\t\tnext.ServeHTTP(w, r)\n\t\t})\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/path_rewrite.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"strings\"\n)\n\n// PathRewrite is a simple middleware which allows you to rewrite the request URL path.\nfunc PathRewrite(old, new string) func(http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\tr.URL.Path = strings.Replace(r.URL.Path, old, new, 1)\n\t\t\tnext.ServeHTTP(w, r)\n\t\t})\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/profiler.go",
"content": "package middleware\n\nimport (\n\t\"expvar\"\n\t\"net/http\"\n\t\"net/http/pprof\"\n\n\t\"github.com/go-chi/chi/v5\"\n)\n\n// Profiler is a convenient subrouter used for mounting net/http/pprof. ie.\n//\n//\tfunc MyService() http.Handler {\n//\t\tr := chi.NewRouter()\n//\t\t// ..middlewares\n//\t\tr.Mount(\"/debug\", middleware.Profiler())\n//\t\t// ..routes\n//\t\treturn r\n//\t}\nfunc Profiler() http.Handler {\n\tr := chi.NewRouter()\n\tr.Use(NoCache)\n\n\tr.Get(\"/\", func(w http.ResponseWriter, r *http.Request) {\n\t\thttp.Redirect(w, r, r.RequestURI+\"/pprof/\", http.StatusMovedPermanently)\n\t})\n\tr.HandleFunc(\"/pprof\", func(w http.ResponseWriter, r *http.Request) {\n\t\thttp.Redirect(w, r, r.RequestURI+\"/\", http.StatusMovedPermanently)\n\t})\n\n\tr.HandleFunc(\"/pprof/*\", pprof.Index)\n\tr.HandleFunc(\"/pprof/cmdline\", pprof.Cmdline)\n\tr.HandleFunc(\"/pprof/profile\", pprof.Profile)\n\tr.HandleFunc(\"/pprof/symbol\", pprof.Symbol)\n\tr.HandleFunc(\"/pprof/trace\", pprof.Trace)\n\tr.Handle(\"/vars\", expvar.Handler())\n\n\tr.Handle(\"/pprof/goroutine\", pprof.Handler(\"goroutine\"))\n\tr.Handle(\"/pprof/threadcreate\", pprof.Handler(\"threadcreate\"))\n\tr.Handle(\"/pprof/mutex\", pprof.Handler(\"mutex\"))\n\tr.Handle(\"/pprof/heap\", pprof.Handler(\"heap\"))\n\tr.Handle(\"/pprof/block\", pprof.Handler(\"block\"))\n\tr.Handle(\"/pprof/allocs\", pprof.Handler(\"allocs\"))\n\n\treturn r\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/realip.go",
"content": "package middleware\n\n// Ported from Goji's middleware, source:\n// https://github.com/zenazn/goji/tree/master/web/middleware\n\nimport (\n\t\"net\"\n\t\"net/http\"\n\t\"strings\"\n)\n\nvar trueClientIP = http.CanonicalHeaderKey(\"True-Client-IP\")\nvar xForwardedFor = http.CanonicalHeaderKey(\"X-Forwarded-For\")\nvar xRealIP = http.CanonicalHeaderKey(\"X-Real-IP\")\n\n// RealIP is a middleware that sets a http.Request's RemoteAddr to the results\n// of parsing either the True-Client-IP, X-Real-IP or the X-Forwarded-For headers\n// (in that order).\n//\n// This middleware should be inserted fairly early in the middleware stack to\n// ensure that subsequent layers (e.g., request loggers) which examine the\n// RemoteAddr will see the intended value.\n//\n// You should only use this middleware if you can trust the headers passed to\n// you (in particular, the two headers this middleware uses), for example\n// because you have placed a reverse proxy like HAProxy or nginx in front of\n// chi. If your reverse proxies are configured to pass along arbitrary header\n// values from the client, or if you use this middleware without a reverse\n// proxy, malicious clients will be able to make you very sad (or, depending on\n// how you're using RemoteAddr, vulnerable to an attack of some sort).\nfunc RealIP(h http.Handler) http.Handler {\n\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\tif rip := realIP(r); rip != \"\" {\n\t\t\tr.RemoteAddr = rip\n\t\t}\n\t\th.ServeHTTP(w, r)\n\t}\n\n\treturn http.HandlerFunc(fn)\n}\n\nfunc realIP(r *http.Request) string {\n\tvar ip string\n\n\tif tcip := r.Header.Get(trueClientIP); tcip != \"\" {\n\t\tip = tcip\n\t} else if xrip := r.Header.Get(xRealIP); xrip != \"\" {\n\t\tip = xrip\n\t} else if xff := r.Header.Get(xForwardedFor); xff != \"\" {\n\t\ti := strings.Index(xff, \",\")\n\t\tif i == -1 {\n\t\t\ti = len(xff)\n\t\t}\n\t\tip = xff[:i]\n\t}\n\tif ip == \"\" || net.ParseIP(ip) == nil {\n\t\treturn \"\"\n\t}\n\treturn ip\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/recoverer.go",
"content": "package middleware\n\n// The original work was derived from Goji's middleware, source:\n// https://github.com/zenazn/goji/tree/master/web/middleware\n\nimport (\n\t\"bytes\"\n\t\"errors\"\n\t\"fmt\"\n\t\"io\"\n\t\"net/http\"\n\t\"os\"\n\t\"runtime/debug\"\n\t\"strings\"\n)\n\n// Recoverer is a middleware that recovers from panics, logs the panic (and a\n// backtrace), and returns a HTTP 500 (Internal Server Error) status if\n// possible. Recoverer prints a request ID if one is provided.\n//\n// Alternatively, look at https://github.com/go-chi/httplog middleware pkgs.\nfunc Recoverer(next http.Handler) http.Handler {\n\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\tdefer func() {\n\t\t\tif rvr := recover(); rvr != nil {\n\t\t\t\tif rvr == http.ErrAbortHandler {\n\t\t\t\t\t// we don't recover http.ErrAbortHandler so the response\n\t\t\t\t\t// to the client is aborted, this should not be logged\n\t\t\t\t\tpanic(rvr)\n\t\t\t\t}\n\n\t\t\t\tlogEntry := GetLogEntry(r)\n\t\t\t\tif logEntry != nil {\n\t\t\t\t\tlogEntry.Panic(rvr, debug.Stack())\n\t\t\t\t} else {\n\t\t\t\t\tPrintPrettyStack(rvr)\n\t\t\t\t}\n\n\t\t\t\tif r.Header.Get(\"Connection\") != \"Upgrade\" {\n\t\t\t\t\tw.WriteHeader(http.StatusInternalServerError)\n\t\t\t\t}\n\t\t\t}\n\t\t}()\n\n\t\tnext.ServeHTTP(w, r)\n\t}\n\n\treturn http.HandlerFunc(fn)\n}\n\n// for ability to test the PrintPrettyStack function\nvar recovererErrorWriter io.Writer = os.Stderr\n\nfunc PrintPrettyStack(rvr interface{}) {\n\tdebugStack := debug.Stack()\n\ts := prettyStack{}\n\tout, err := s.parse(debugStack, rvr)\n\tif err == nil {\n\t\trecovererErrorWriter.Write(out)\n\t} else {\n\t\t// print stdlib output as a fallback\n\t\tos.Stderr.Write(debugStack)\n\t}\n}\n\ntype prettyStack struct {\n}\n\nfunc (s prettyStack) parse(debugStack []byte, rvr interface{}) ([]byte, error) {\n\tvar err error\n\tuseColor := true\n\tbuf := &bytes.Buffer{}\n\n\tcW(buf, false, bRed, \"\\n\")\n\tcW(buf, useColor, bCyan, \" panic: \")\n\tcW(buf, useColor, bBlue, \"%v\", rvr)\n\tcW(buf, false, bWhite, \"\\n \\n\")\n\n\t// process debug stack info\n\tstack := strings.Split(string(debugStack), \"\\n\")\n\tlines := []string{}\n\n\t// locate panic line, as we may have nested panics\n\tfor i := len(stack) - 1; i > 0; i-- {\n\t\tlines = append(lines, stack[i])\n\t\tif strings.HasPrefix(stack[i], \"panic(\") {\n\t\t\tlines = lines[0 : len(lines)-2] // remove boilerplate\n\t\t\tbreak\n\t\t}\n\t}\n\n\t// reverse\n\tfor i := len(lines)/2 - 1; i >= 0; i-- {\n\t\topp := len(lines) - 1 - i\n\t\tlines[i], lines[opp] = lines[opp], lines[i]\n\t}\n\n\t// decorate\n\tfor i, line := range lines {\n\t\tlines[i], err = s.decorateLine(line, useColor, i)\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\n\tfor _, l := range lines {\n\t\tfmt.Fprintf(buf, \"%s\", l)\n\t}\n\treturn buf.Bytes(), nil\n}\n\nfunc (s prettyStack) decorateLine(line string, useColor bool, num int) (string, error) {\n\tline = strings.TrimSpace(line)\n\tif strings.HasPrefix(line, \"\\t\") || strings.Contains(line, \".go:\") {\n\t\treturn s.decorateSourceLine(line, useColor, num)\n\t}\n\tif strings.HasSuffix(line, \")\") {\n\t\treturn s.decorateFuncCallLine(line, useColor, num)\n\t}\n\tif strings.HasPrefix(line, \"\\t\") {\n\t\treturn strings.Replace(line, \"\\t\", \" \", 1), nil\n\t}\n\treturn fmt.Sprintf(\" %s\\n\", line), nil\n}\n\nfunc (s prettyStack) decorateFuncCallLine(line string, useColor bool, num int) (string, error) {\n\tidx := strings.LastIndex(line, \"(\")\n\tif idx < 0 {\n\t\treturn \"\", errors.New(\"not a func call line\")\n\t}\n\n\tbuf := &bytes.Buffer{}\n\tpkg := line[0:idx]\n\t// addr := line[idx:]\n\tmethod := \"\"\n\n\tif idx := strings.LastIndex(pkg, string(os.PathSeparator)); idx < 0 {\n\t\tif idx := strings.Index(pkg, \".\"); idx > 0 {\n\t\t\tmethod = pkg[idx:]\n\t\t\tpkg = pkg[0:idx]\n\t\t}\n\t} else {\n\t\tmethod = pkg[idx+1:]\n\t\tpkg = pkg[0 : idx+1]\n\t\tif idx := strings.Index(method, \".\"); idx > 0 {\n\t\t\tpkg += method[0:idx]\n\t\t\tmethod = method[idx:]\n\t\t}\n\t}\n\tpkgColor := nYellow\n\tmethodColor := bGreen\n\n\tif num == 0 {\n\t\tcW(buf, useColor, bRed, \" -> \")\n\t\tpkgColor = bMagenta\n\t\tmethodColor = bRed\n\t} else {\n\t\tcW(buf, useColor, bWhite, \" \")\n\t}\n\tcW(buf, useColor, pkgColor, \"%s\", pkg)\n\tcW(buf, useColor, methodColor, \"%s\\n\", method)\n\t// cW(buf, useColor, nBlack, \"%s\", addr)\n\treturn buf.String(), nil\n}\n\nfunc (s prettyStack) decorateSourceLine(line string, useColor bool, num int) (string, error) {\n\tidx := strings.LastIndex(line, \".go:\")\n\tif idx < 0 {\n\t\treturn \"\", errors.New(\"not a source line\")\n\t}\n\n\tbuf := &bytes.Buffer{}\n\tpath := line[0 : idx+3]\n\tlineno := line[idx+3:]\n\n\tidx = strings.LastIndex(path, string(os.PathSeparator))\n\tdir := path[0 : idx+1]\n\tfile := path[idx+1:]\n\n\tidx = strings.Index(lineno, \" \")\n\tif idx > 0 {\n\t\tlineno = lineno[0:idx]\n\t}\n\tfileColor := bCyan\n\tlineColor := bGreen\n\n\tif num == 1 {\n\t\tcW(buf, useColor, bRed, \" -> \")\n\t\tfileColor = bRed\n\t\tlineColor = bMagenta\n\t} else {\n\t\tcW(buf, false, bWhite, \" \")\n\t}\n\tcW(buf, useColor, bWhite, \"%s\", dir)\n\tcW(buf, useColor, fileColor, \"%s\", file)\n\tcW(buf, useColor, lineColor, \"%s\", lineno)\n\tif num == 1 {\n\t\tcW(buf, false, bWhite, \"\\n\")\n\t}\n\tcW(buf, false, bWhite, \"\\n\")\n\n\treturn buf.String(), nil\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/request_id.go",
"content": "package middleware\n\n// Ported from Goji's middleware, source:\n// https://github.com/zenazn/goji/tree/master/web/middleware\n\nimport (\n\t\"context\"\n\t\"crypto/rand\"\n\t\"encoding/base64\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"os\"\n\t\"strings\"\n\t\"sync/atomic\"\n)\n\n// Key to use when setting the request ID.\ntype ctxKeyRequestID int\n\n// RequestIDKey is the key that holds the unique request ID in a request context.\nconst RequestIDKey ctxKeyRequestID = 0\n\n// RequestIDHeader is the name of the HTTP Header which contains the request id.\n// Exported so that it can be changed by developers\nvar RequestIDHeader = \"X-Request-Id\"\n\nvar prefix string\nvar reqid uint64\n\n// A quick note on the statistics here: we're trying to calculate the chance that\n// two randomly generated base62 prefixes will collide. We use the formula from\n// http://en.wikipedia.org/wiki/Birthday_problem\n//\n// P[m, n] \\approx 1 - e^{-m^2/2n}\n//\n// We ballpark an upper bound for $m$ by imagining (for whatever reason) a server\n// that restarts every second over 10 years, for $m = 86400 * 365 * 10 = 315360000$\n//\n// For a $k$ character base-62 identifier, we have $n(k) = 62^k$\n//\n// Plugging this in, we find $P[m, n(10)] \\approx 5.75%$, which is good enough for\n// our purposes, and is surely more than anyone would ever need in practice -- a\n// process that is rebooted a handful of times a day for a hundred years has less\n// than a millionth of a percent chance of generating two colliding IDs.\n\nfunc init() {\n\thostname, err := os.Hostname()\n\tif hostname == \"\" || err != nil {\n\t\thostname = \"localhost\"\n\t}\n\tvar buf [12]byte\n\tvar b64 string\n\tfor len(b64) < 10 {\n\t\trand.Read(buf[:])\n\t\tb64 = base64.StdEncoding.EncodeToString(buf[:])\n\t\tb64 = strings.NewReplacer(\"+\", \"\", \"/\", \"\").Replace(b64)\n\t}\n\n\tprefix = fmt.Sprintf(\"%s/%s\", hostname, b64[0:10])\n}\n\n// RequestID is a middleware that injects a request ID into the context of each\n// request. A request ID is a string of the form \"host.example.com/random-0001\",\n// where \"random\" is a base62 random string that uniquely identifies this go\n// process, and where the last number is an atomically incremented request\n// counter.\nfunc RequestID(next http.Handler) http.Handler {\n\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\tctx := r.Context()\n\t\trequestID := r.Header.Get(RequestIDHeader)\n\t\tif requestID == \"\" {\n\t\t\tmyid := atomic.AddUint64(&reqid, 1)\n\t\t\trequestID = fmt.Sprintf(\"%s-%06d\", prefix, myid)\n\t\t}\n\t\tctx = context.WithValue(ctx, RequestIDKey, requestID)\n\t\tnext.ServeHTTP(w, r.WithContext(ctx))\n\t}\n\treturn http.HandlerFunc(fn)\n}\n\n// GetReqID returns a request ID from the given context if one is present.\n// Returns the empty string if a request ID cannot be found.\nfunc GetReqID(ctx context.Context) string {\n\tif ctx == nil {\n\t\treturn \"\"\n\t}\n\tif reqID, ok := ctx.Value(RequestIDKey).(string); ok {\n\t\treturn reqID\n\t}\n\treturn \"\"\n}\n\n// NextRequestID generates the next request ID in the sequence.\nfunc NextRequestID() uint64 {\n\treturn atomic.AddUint64(&reqid, 1)\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/request_size.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n)\n\n// RequestSize is a middleware that will limit request sizes to a specified\n// number of bytes. It uses MaxBytesReader to do so.\nfunc RequestSize(bytes int64) func(http.Handler) http.Handler {\n\tf := func(h http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\tr.Body = http.MaxBytesReader(w, r.Body, bytes)\n\t\t\th.ServeHTTP(w, r)\n\t\t}\n\t\treturn http.HandlerFunc(fn)\n\t}\n\treturn f\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/route_headers.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"strings\"\n)\n\n// RouteHeaders is a neat little header-based router that allows you to direct\n// the flow of a request through a middleware stack based on a request header.\n//\n// For example, lets say you'd like to setup multiple routers depending on the\n// request Host header, you could then do something as so:\n//\n//\tr := chi.NewRouter()\n//\trSubdomain := chi.NewRouter()\n//\tr.Use(middleware.RouteHeaders().\n//\t\tRoute(\"Host\", \"example.com\", middleware.New(r)).\n//\t\tRoute(\"Host\", \"*.example.com\", middleware.New(rSubdomain)).\n//\t\tHandler)\n//\tr.Get(\"/\", h)\n//\trSubdomain.Get(\"/\", h2)\n//\n// Another example, imagine you want to setup multiple CORS handlers, where for\n// your origin servers you allow authorized requests, but for third-party public\n// requests, authorization is disabled.\n//\n//\tr := chi.NewRouter()\n//\tr.Use(middleware.RouteHeaders().\n//\t\tRoute(\"Origin\", \"https://app.skyweaver.net\", cors.Handler(cors.Options{\n//\t\t\tAllowedOrigins: []string{\"https://api.skyweaver.net\"},\n//\t\t\tAllowedMethods: []string{\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\"},\n//\t\t\tAllowedHeaders: []string{\"Accept\", \"Authorization\", \"Content-Type\"},\n//\t\t\tAllowCredentials: true, // <----------<<< allow credentials\n//\t\t})).\n//\t\tRoute(\"Origin\", \"*\", cors.Handler(cors.Options{\n//\t\t\tAllowedOrigins: []string{\"*\"},\n//\t\t\tAllowedMethods: []string{\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\"},\n//\t\t\tAllowedHeaders: []string{\"Accept\", \"Content-Type\"},\n//\t\t\tAllowCredentials: false, // <----------<<< do not allow credentials\n//\t\t})).\n//\t\tHandler)\nfunc RouteHeaders() HeaderRouter {\n\treturn HeaderRouter{}\n}\n\ntype HeaderRouter map[string][]HeaderRoute\n\nfunc (hr HeaderRouter) Route(header, match string, middlewareHandler func(next http.Handler) http.Handler) HeaderRouter {\n\theader = strings.ToLower(header)\n\tk := hr[header]\n\tif k == nil {\n\t\thr[header] = []HeaderRoute{}\n\t}\n\thr[header] = append(hr[header], HeaderRoute{MatchOne: NewPattern(match), Middleware: middlewareHandler})\n\treturn hr\n}\n\nfunc (hr HeaderRouter) RouteAny(header string, match []string, middlewareHandler func(next http.Handler) http.Handler) HeaderRouter {\n\theader = strings.ToLower(header)\n\tk := hr[header]\n\tif k == nil {\n\t\thr[header] = []HeaderRoute{}\n\t}\n\tpatterns := []Pattern{}\n\tfor _, m := range match {\n\t\tpatterns = append(patterns, NewPattern(m))\n\t}\n\thr[header] = append(hr[header], HeaderRoute{MatchAny: patterns, Middleware: middlewareHandler})\n\treturn hr\n}\n\nfunc (hr HeaderRouter) RouteDefault(handler func(next http.Handler) http.Handler) HeaderRouter {\n\thr[\"*\"] = []HeaderRoute{{Middleware: handler}}\n\treturn hr\n}\n\nfunc (hr HeaderRouter) Handler(next http.Handler) http.Handler {\n\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\tif len(hr) == 0 {\n\t\t\t// skip if no routes set\n\t\t\tnext.ServeHTTP(w, r)\n\t\t}\n\n\t\t// find first matching header route, and continue\n\t\tfor header, matchers := range hr {\n\t\t\theaderValue := r.Header.Get(header)\n\t\t\tif headerValue == \"\" {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\theaderValue = strings.ToLower(headerValue)\n\t\t\tfor _, matcher := range matchers {\n\t\t\t\tif matcher.IsMatch(headerValue) {\n\t\t\t\t\tmatcher.Middleware(next).ServeHTTP(w, r)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// if no match, check for \"*\" default route\n\t\tmatcher, ok := hr[\"*\"]\n\t\tif !ok || matcher[0].Middleware == nil {\n\t\t\tnext.ServeHTTP(w, r)\n\t\t\treturn\n\t\t}\n\t\tmatcher[0].Middleware(next).ServeHTTP(w, r)\n\t})\n}\n\ntype HeaderRoute struct {\n\tMiddleware func(next http.Handler) http.Handler\n\tMatchOne Pattern\n\tMatchAny []Pattern\n}\n\nfunc (r HeaderRoute) IsMatch(value string) bool {\n\tif len(r.MatchAny) > 0 {\n\t\tfor _, m := range r.MatchAny {\n\t\t\tif m.Match(value) {\n\t\t\t\treturn true\n\t\t\t}\n\t\t}\n\t} else if r.MatchOne.Match(value) {\n\t\treturn true\n\t}\n\treturn false\n}\n\ntype Pattern struct {\n\tprefix string\n\tsuffix string\n\twildcard bool\n}\n\nfunc NewPattern(value string) Pattern {\n\tp := Pattern{}\n\tif i := strings.IndexByte(value, '*'); i >= 0 {\n\t\tp.wildcard = true\n\t\tp.prefix = value[0:i]\n\t\tp.suffix = value[i+1:]\n\t} else {\n\t\tp.prefix = value\n\t}\n\treturn p\n}\n\nfunc (p Pattern) Match(v string) bool {\n\tif !p.wildcard {\n\t\treturn p.prefix == v\n\t}\n\treturn len(v) >= len(p.prefix+p.suffix) && strings.HasPrefix(v, p.prefix) && strings.HasSuffix(v, p.suffix)\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/strip.go",
"content": "package middleware\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\n\t\"github.com/go-chi/chi/v5\"\n)\n\n// StripSlashes is a middleware that will match request paths with a trailing\n// slash, strip it from the path and continue routing through the mux, if a route\n// matches, then it will serve the handler.\nfunc StripSlashes(next http.Handler) http.Handler {\n\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\tvar path string\n\t\trctx := chi.RouteContext(r.Context())\n\t\tif rctx != nil && rctx.RoutePath != \"\" {\n\t\t\tpath = rctx.RoutePath\n\t\t} else {\n\t\t\tpath = r.URL.Path\n\t\t}\n\t\tif len(path) > 1 && path[len(path)-1] == '/' {\n\t\t\tnewPath := path[:len(path)-1]\n\t\t\tif rctx == nil {\n\t\t\t\tr.URL.Path = newPath\n\t\t\t} else {\n\t\t\t\trctx.RoutePath = newPath\n\t\t\t}\n\t\t}\n\t\tnext.ServeHTTP(w, r)\n\t}\n\treturn http.HandlerFunc(fn)\n}\n\n// RedirectSlashes is a middleware that will match request paths with a trailing\n// slash and redirect to the same path, less the trailing slash.\n//\n// NOTE: RedirectSlashes middleware is *incompatible* with http.FileServer,\n// see https://github.com/go-chi/chi/issues/343\nfunc RedirectSlashes(next http.Handler) http.Handler {\n\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\tvar path string\n\t\trctx := chi.RouteContext(r.Context())\n\t\tif rctx != nil && rctx.RoutePath != \"\" {\n\t\t\tpath = rctx.RoutePath\n\t\t} else {\n\t\t\tpath = r.URL.Path\n\t\t}\n\t\tif len(path) > 1 && path[len(path)-1] == '/' {\n\t\t\tif r.URL.RawQuery != \"\" {\n\t\t\t\tpath = fmt.Sprintf(\"%s?%s\", path[:len(path)-1], r.URL.RawQuery)\n\t\t\t} else {\n\t\t\t\tpath = path[:len(path)-1]\n\t\t\t}\n\t\t\tredirectURL := fmt.Sprintf(\"//%s%s\", r.Host, path)\n\t\t\thttp.Redirect(w, r, redirectURL, 301)\n\t\t\treturn\n\t\t}\n\t\tnext.ServeHTTP(w, r)\n\t}\n\treturn http.HandlerFunc(fn)\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/sunset.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"time\"\n)\n\n// Sunset set Deprecation/Sunset header to response\n// This can be used to enable Sunset in a route or a route group\n// For more: https://www.rfc-editor.org/rfc/rfc8594.html\nfunc Sunset(sunsetAt time.Time, links ...string) func(http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\tif !sunsetAt.IsZero() {\n\t\t\t\tw.Header().Set(\"Sunset\", sunsetAt.Format(http.TimeFormat))\n\t\t\t\tw.Header().Set(\"Deprecation\", sunsetAt.Format(http.TimeFormat))\n\n\t\t\t\tfor _, link := range links {\n\t\t\t\t\tw.Header().Add(\"Link\", link)\n\t\t\t\t}\n\t\t\t}\n\t\t\tnext.ServeHTTP(w, r)\n\t\t})\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/supress_notfound.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\n\t\"github.com/go-chi/chi/v5\"\n)\n\n// SupressNotFound will quickly respond with a 404 if the route is not found\n// and will not continue to the next middleware handler.\n//\n// This is handy to put at the top of your middleware stack to avoid unnecessary\n// processing of requests that are not going to match any routes anyway. For\n// example its super annoying to see a bunch of 404's in your logs from bots.\nfunc SupressNotFound(router *chi.Mux) func(next http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\trctx := chi.RouteContext(r.Context())\n\t\t\tmatch := rctx.Routes.Match(rctx, r.Method, r.URL.Path)\n\t\t\tif !match {\n\t\t\t\trouter.NotFoundHandler().ServeHTTP(w, r)\n\t\t\t\treturn\n\t\t\t}\n\t\t\tnext.ServeHTTP(w, r)\n\t\t})\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/terminal.go",
"content": "package middleware\n\n// Ported from Goji's middleware, source:\n// https://github.com/zenazn/goji/tree/master/web/middleware\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n)\n\nvar (\n\t// Normal colors\n\tnBlack = []byte{'\\033', '[', '3', '0', 'm'}\n\tnRed = []byte{'\\033', '[', '3', '1', 'm'}\n\tnGreen = []byte{'\\033', '[', '3', '2', 'm'}\n\tnYellow = []byte{'\\033', '[', '3', '3', 'm'}\n\tnBlue = []byte{'\\033', '[', '3', '4', 'm'}\n\tnMagenta = []byte{'\\033', '[', '3', '5', 'm'}\n\tnCyan = []byte{'\\033', '[', '3', '6', 'm'}\n\tnWhite = []byte{'\\033', '[', '3', '7', 'm'}\n\t// Bright colors\n\tbBlack = []byte{'\\033', '[', '3', '0', ';', '1', 'm'}\n\tbRed = []byte{'\\033', '[', '3', '1', ';', '1', 'm'}\n\tbGreen = []byte{'\\033', '[', '3', '2', ';', '1', 'm'}\n\tbYellow = []byte{'\\033', '[', '3', '3', ';', '1', 'm'}\n\tbBlue = []byte{'\\033', '[', '3', '4', ';', '1', 'm'}\n\tbMagenta = []byte{'\\033', '[', '3', '5', ';', '1', 'm'}\n\tbCyan = []byte{'\\033', '[', '3', '6', ';', '1', 'm'}\n\tbWhite = []byte{'\\033', '[', '3', '7', ';', '1', 'm'}\n\n\treset = []byte{'\\033', '[', '0', 'm'}\n)\n\nvar IsTTY bool\n\nfunc init() {\n\t// This is sort of cheating: if stdout is a character device, we assume\n\t// that means it's a TTY. Unfortunately, there are many non-TTY\n\t// character devices, but fortunately stdout is rarely set to any of\n\t// them.\n\t//\n\t// We could solve this properly by pulling in a dependency on\n\t// code.google.com/p/go.crypto/ssh/terminal, for instance, but as a\n\t// heuristic for whether to print in color or in black-and-white, I'd\n\t// really rather not.\n\tfi, err := os.Stdout.Stat()\n\tif err == nil {\n\t\tm := os.ModeDevice | os.ModeCharDevice\n\t\tIsTTY = fi.Mode()&m == m\n\t}\n}\n\n// colorWrite\nfunc cW(w io.Writer, useColor bool, color []byte, s string, args ...interface{}) {\n\tif IsTTY && useColor {\n\t\tw.Write(color)\n\t}\n\tfmt.Fprintf(w, s, args...)\n\tif IsTTY && useColor {\n\t\tw.Write(reset)\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/throttle.go",
"content": "package middleware\n\nimport (\n\t\"net/http\"\n\t\"strconv\"\n\t\"time\"\n)\n\nconst (\n\terrCapacityExceeded = \"Server capacity exceeded.\"\n\terrTimedOut = \"Timed out while waiting for a pending request to complete.\"\n\terrContextCanceled = \"Context was canceled.\"\n)\n\nvar (\n\tdefaultBacklogTimeout = time.Second * 60\n)\n\n// ThrottleOpts represents a set of throttling options.\ntype ThrottleOpts struct {\n\tRetryAfterFn func(ctxDone bool) time.Duration\n\tLimit int\n\tBacklogLimit int\n\tBacklogTimeout time.Duration\n}\n\n// Throttle is a middleware that limits number of currently processed requests\n// at a time across all users. Note: Throttle is not a rate-limiter per user,\n// instead it just puts a ceiling on the number of currently in-flight requests\n// being processed from the point from where the Throttle middleware is mounted.\nfunc Throttle(limit int) func(http.Handler) http.Handler {\n\treturn ThrottleWithOpts(ThrottleOpts{Limit: limit, BacklogTimeout: defaultBacklogTimeout})\n}\n\n// ThrottleBacklog is a middleware that limits number of currently processed\n// requests at a time and provides a backlog for holding a finite number of\n// pending requests.\nfunc ThrottleBacklog(limit, backlogLimit int, backlogTimeout time.Duration) func(http.Handler) http.Handler {\n\treturn ThrottleWithOpts(ThrottleOpts{Limit: limit, BacklogLimit: backlogLimit, BacklogTimeout: backlogTimeout})\n}\n\n// ThrottleWithOpts is a middleware that limits number of currently processed requests using passed ThrottleOpts.\nfunc ThrottleWithOpts(opts ThrottleOpts) func(http.Handler) http.Handler {\n\tif opts.Limit < 1 {\n\t\tpanic(\"chi/middleware: Throttle expects limit > 0\")\n\t}\n\n\tif opts.BacklogLimit < 0 {\n\t\tpanic(\"chi/middleware: Throttle expects backlogLimit to be positive\")\n\t}\n\n\tt := throttler{\n\t\ttokens: make(chan token, opts.Limit),\n\t\tbacklogTokens: make(chan token, opts.Limit+opts.BacklogLimit),\n\t\tbacklogTimeout: opts.BacklogTimeout,\n\t\tretryAfterFn: opts.RetryAfterFn,\n\t}\n\n\t// Filling tokens.\n\tfor i := 0; i < opts.Limit+opts.BacklogLimit; i++ {\n\t\tif i < opts.Limit {\n\t\t\tt.tokens <- token{}\n\t\t}\n\t\tt.backlogTokens <- token{}\n\t}\n\n\treturn func(next http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\tctx := r.Context()\n\n\t\t\tselect {\n\n\t\t\tcase <-ctx.Done():\n\t\t\t\tt.setRetryAfterHeaderIfNeeded(w, true)\n\t\t\t\thttp.Error(w, errContextCanceled, http.StatusTooManyRequests)\n\t\t\t\treturn\n\n\t\t\tcase btok := <-t.backlogTokens:\n\t\t\t\ttimer := time.NewTimer(t.backlogTimeout)\n\n\t\t\t\tdefer func() {\n\t\t\t\t\tt.backlogTokens <- btok\n\t\t\t\t}()\n\n\t\t\t\tselect {\n\t\t\t\tcase <-timer.C:\n\t\t\t\t\tt.setRetryAfterHeaderIfNeeded(w, false)\n\t\t\t\t\thttp.Error(w, errTimedOut, http.StatusTooManyRequests)\n\t\t\t\t\treturn\n\t\t\t\tcase <-ctx.Done():\n\t\t\t\t\ttimer.Stop()\n\t\t\t\t\tt.setRetryAfterHeaderIfNeeded(w, true)\n\t\t\t\t\thttp.Error(w, errContextCanceled, http.StatusTooManyRequests)\n\t\t\t\t\treturn\n\t\t\t\tcase tok := <-t.tokens:\n\t\t\t\t\tdefer func() {\n\t\t\t\t\t\ttimer.Stop()\n\t\t\t\t\t\tt.tokens <- tok\n\t\t\t\t\t}()\n\t\t\t\t\tnext.ServeHTTP(w, r)\n\t\t\t\t}\n\t\t\t\treturn\n\n\t\t\tdefault:\n\t\t\t\tt.setRetryAfterHeaderIfNeeded(w, false)\n\t\t\t\thttp.Error(w, errCapacityExceeded, http.StatusTooManyRequests)\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\n\t\treturn http.HandlerFunc(fn)\n\t}\n}\n\n// token represents a request that is being processed.\ntype token struct{}\n\n// throttler limits number of currently processed requests at a time.\ntype throttler struct {\n\ttokens chan token\n\tbacklogTokens chan token\n\tretryAfterFn func(ctxDone bool) time.Duration\n\tbacklogTimeout time.Duration\n}\n\n// setRetryAfterHeaderIfNeeded sets Retry-After HTTP header if corresponding retryAfterFn option of throttler is initialized.\nfunc (t throttler) setRetryAfterHeaderIfNeeded(w http.ResponseWriter, ctxDone bool) {\n\tif t.retryAfterFn == nil {\n\t\treturn\n\t}\n\tw.Header().Set(\"Retry-After\", strconv.Itoa(int(t.retryAfterFn(ctxDone).Seconds())))\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/timeout.go",
"content": "package middleware\n\nimport (\n\t\"context\"\n\t\"net/http\"\n\t\"time\"\n)\n\n// Timeout is a middleware that cancels ctx after a given timeout and return\n// a 504 Gateway Timeout error to the client.\n//\n// It's required that you select the ctx.Done() channel to check for the signal\n// if the context has reached its deadline and return, otherwise the timeout\n// signal will be just ignored.\n//\n// ie. a route/handler may look like:\n//\n//\tr.Get(\"/long\", func(w http.ResponseWriter, r *http.Request) {\n//\t\tctx := r.Context()\n//\t\tprocessTime := time.Duration(rand.Intn(4)+1) * time.Second\n//\n//\t\tselect {\n//\t\tcase <-ctx.Done():\n//\t\t\treturn\n//\n//\t\tcase <-time.After(processTime):\n//\t\t\t// The above channel simulates some hard work.\n//\t\t}\n//\n//\t\tw.Write([]byte(\"done\"))\n//\t})\nfunc Timeout(timeout time.Duration) func(next http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\tctx, cancel := context.WithTimeout(r.Context(), timeout)\n\t\t\tdefer func() {\n\t\t\t\tcancel()\n\t\t\t\tif ctx.Err() == context.DeadlineExceeded {\n\t\t\t\t\tw.WriteHeader(http.StatusGatewayTimeout)\n\t\t\t\t}\n\t\t\t}()\n\n\t\t\tr = r.WithContext(ctx)\n\t\t\tnext.ServeHTTP(w, r)\n\t\t}\n\t\treturn http.HandlerFunc(fn)\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/url_format.go",
"content": "package middleware\n\nimport (\n\t\"context\"\n\t\"net/http\"\n\t\"strings\"\n\n\t\"github.com/go-chi/chi/v5\"\n)\n\nvar (\n\t// URLFormatCtxKey is the context.Context key to store the URL format data\n\t// for a request.\n\tURLFormatCtxKey = &contextKey{\"URLFormat\"}\n)\n\n// URLFormat is a middleware that parses the url extension from a request path and stores it\n// on the context as a string under the key `middleware.URLFormatCtxKey`. The middleware will\n// trim the suffix from the routing path and continue routing.\n//\n// Routers should not include a url parameter for the suffix when using this middleware.\n//\n// Sample usage for url paths `/articles/1`, `/articles/1.json` and `/articles/1.xml`:\n//\n//\tfunc routes() http.Handler {\n//\t\tr := chi.NewRouter()\n//\t\tr.Use(middleware.URLFormat)\n//\n//\t\tr.Get(\"/articles/{id}\", ListArticles)\n//\n//\t\treturn r\n//\t}\n//\n//\tfunc ListArticles(w http.ResponseWriter, r *http.Request) {\n//\t\turlFormat, _ := r.Context().Value(middleware.URLFormatCtxKey).(string)\n//\n//\t\tswitch urlFormat {\n//\t\tcase \"json\":\n//\t\t\trender.JSON(w, r, articles)\n//\t\tcase \"xml:\"\n//\t\t\trender.XML(w, r, articles)\n//\t\tdefault:\n//\t\t\trender.JSON(w, r, articles)\n//\t\t}\n//\t}\nfunc URLFormat(next http.Handler) http.Handler {\n\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\tctx := r.Context()\n\n\t\tvar format string\n\t\tpath := r.URL.Path\n\n\t\trctx := chi.RouteContext(r.Context())\n\t\tif rctx != nil && rctx.RoutePath != \"\" {\n\t\t\tpath = rctx.RoutePath\n\t\t}\n\n\t\tif strings.Index(path, \".\") > 0 {\n\t\t\tbase := strings.LastIndex(path, \"/\")\n\t\t\tidx := strings.LastIndex(path[base:], \".\")\n\n\t\t\tif idx > 0 {\n\t\t\t\tidx += base\n\t\t\t\tformat = path[idx+1:]\n\n\t\t\t\trctx.RoutePath = path[:idx]\n\t\t\t}\n\t\t}\n\n\t\tr = r.WithContext(context.WithValue(ctx, URLFormatCtxKey, format))\n\n\t\tnext.ServeHTTP(w, r)\n\t}\n\treturn http.HandlerFunc(fn)\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/value.go",
"content": "package middleware\n\nimport (\n\t\"context\"\n\t\"net/http\"\n)\n\n// WithValue is a middleware that sets a given key/value in a context chain.\nfunc WithValue(key, val interface{}) func(next http.Handler) http.Handler {\n\treturn func(next http.Handler) http.Handler {\n\t\tfn := func(w http.ResponseWriter, r *http.Request) {\n\t\t\tr = r.WithContext(context.WithValue(r.Context(), key, val))\n\t\t\tnext.ServeHTTP(w, r)\n\t\t}\n\t\treturn http.HandlerFunc(fn)\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/middleware/wrap_writer.go",
"content": "package middleware\n\n// The original work was derived from Goji's middleware, source:\n// https://github.com/zenazn/goji/tree/master/web/middleware\n\nimport (\n\t\"bufio\"\n\t\"io\"\n\t\"net\"\n\t\"net/http\"\n)\n\n// NewWrapResponseWriter wraps an http.ResponseWriter, returning a proxy that allows you to\n// hook into various parts of the response process.\nfunc NewWrapResponseWriter(w http.ResponseWriter, protoMajor int) WrapResponseWriter {\n\t_, fl := w.(http.Flusher)\n\n\tbw := basicWriter{ResponseWriter: w}\n\n\tif protoMajor == 2 {\n\t\t_, ps := w.(http.Pusher)\n\t\tif fl && ps {\n\t\t\treturn &http2FancyWriter{bw}\n\t\t}\n\t} else {\n\t\t_, hj := w.(http.Hijacker)\n\t\t_, rf := w.(io.ReaderFrom)\n\t\tif fl && hj && rf {\n\t\t\treturn &httpFancyWriter{bw}\n\t\t}\n\t\tif fl && hj {\n\t\t\treturn &flushHijackWriter{bw}\n\t\t}\n\t\tif hj {\n\t\t\treturn &hijackWriter{bw}\n\t\t}\n\t}\n\n\tif fl {\n\t\treturn &flushWriter{bw}\n\t}\n\n\treturn &bw\n}\n\n// WrapResponseWriter is a proxy around an http.ResponseWriter that allows you to hook\n// into various parts of the response process.\ntype WrapResponseWriter interface {\n\thttp.ResponseWriter\n\t// Status returns the HTTP status of the request, or 0 if one has not\n\t// yet been sent.\n\tStatus() int\n\t// BytesWritten returns the total number of bytes sent to the client.\n\tBytesWritten() int\n\t// Tee causes the response body to be written to the given io.Writer in\n\t// addition to proxying the writes through. Only one io.Writer can be\n\t// tee'd to at once: setting a second one will overwrite the first.\n\t// Writes will be sent to the proxy before being written to this\n\t// io.Writer. It is illegal for the tee'd writer to be modified\n\t// concurrently with writes.\n\tTee(io.Writer)\n\t// Unwrap returns the original proxied target.\n\tUnwrap() http.ResponseWriter\n}\n\n// basicWriter wraps a http.ResponseWriter that implements the minimal\n// http.ResponseWriter interface.\ntype basicWriter struct {\n\thttp.ResponseWriter\n\twroteHeader bool\n\tcode int\n\tbytes int\n\ttee io.Writer\n}\n\nfunc (b *basicWriter) WriteHeader(code int) {\n\tif !b.wroteHeader {\n\t\tb.code = code\n\t\tb.wroteHeader = true\n\t\tb.ResponseWriter.WriteHeader(code)\n\t}\n}\n\nfunc (b *basicWriter) Write(buf []byte) (int, error) {\n\tb.maybeWriteHeader()\n\tn, err := b.ResponseWriter.Write(buf)\n\tif b.tee != nil {\n\t\t_, err2 := b.tee.Write(buf[:n])\n\t\t// Prefer errors generated by the proxied writer.\n\t\tif err == nil {\n\t\t\terr = err2\n\t\t}\n\t}\n\tb.bytes += n\n\treturn n, err\n}\n\nfunc (b *basicWriter) maybeWriteHeader() {\n\tif !b.wroteHeader {\n\t\tb.WriteHeader(http.StatusOK)\n\t}\n}\n\nfunc (b *basicWriter) Status() int {\n\treturn b.code\n}\n\nfunc (b *basicWriter) BytesWritten() int {\n\treturn b.bytes\n}\n\nfunc (b *basicWriter) Tee(w io.Writer) {\n\tb.tee = w\n}\n\nfunc (b *basicWriter) Unwrap() http.ResponseWriter {\n\treturn b.ResponseWriter\n}\n\n// flushWriter ...\ntype flushWriter struct {\n\tbasicWriter\n}\n\nfunc (f *flushWriter) Flush() {\n\tf.wroteHeader = true\n\tfl := f.basicWriter.ResponseWriter.(http.Flusher)\n\tfl.Flush()\n}\n\nvar _ http.Flusher = &flushWriter{}\n\n// hijackWriter ...\ntype hijackWriter struct {\n\tbasicWriter\n}\n\nfunc (f *hijackWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {\n\thj := f.basicWriter.ResponseWriter.(http.Hijacker)\n\treturn hj.Hijack()\n}\n\nvar _ http.Hijacker = &hijackWriter{}\n\n// flushHijackWriter ...\ntype flushHijackWriter struct {\n\tbasicWriter\n}\n\nfunc (f *flushHijackWriter) Flush() {\n\tf.wroteHeader = true\n\tfl := f.basicWriter.ResponseWriter.(http.Flusher)\n\tfl.Flush()\n}\n\nfunc (f *flushHijackWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {\n\thj := f.basicWriter.ResponseWriter.(http.Hijacker)\n\treturn hj.Hijack()\n}\n\nvar _ http.Flusher = &flushHijackWriter{}\nvar _ http.Hijacker = &flushHijackWriter{}\n\n// httpFancyWriter is a HTTP writer that additionally satisfies\n// http.Flusher, http.Hijacker, and io.ReaderFrom. It exists for the common case\n// of wrapping the http.ResponseWriter that package http gives you, in order to\n// make the proxied object support the full method set of the proxied object.\ntype httpFancyWriter struct {\n\tbasicWriter\n}\n\nfunc (f *httpFancyWriter) Flush() {\n\tf.wroteHeader = true\n\tfl := f.basicWriter.ResponseWriter.(http.Flusher)\n\tfl.Flush()\n}\n\nfunc (f *httpFancyWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {\n\thj := f.basicWriter.ResponseWriter.(http.Hijacker)\n\treturn hj.Hijack()\n}\n\nfunc (f *http2FancyWriter) Push(target string, opts *http.PushOptions) error {\n\treturn f.basicWriter.ResponseWriter.(http.Pusher).Push(target, opts)\n}\n\nfunc (f *httpFancyWriter) ReadFrom(r io.Reader) (int64, error) {\n\tif f.basicWriter.tee != nil {\n\t\tn, err := io.Copy(&f.basicWriter, r)\n\t\tf.basicWriter.bytes += int(n)\n\t\treturn n, err\n\t}\n\trf := f.basicWriter.ResponseWriter.(io.ReaderFrom)\n\tf.basicWriter.maybeWriteHeader()\n\tn, err := rf.ReadFrom(r)\n\tf.basicWriter.bytes += int(n)\n\treturn n, err\n}\n\nvar _ http.Flusher = &httpFancyWriter{}\nvar _ http.Hijacker = &httpFancyWriter{}\nvar _ http.Pusher = &http2FancyWriter{}\nvar _ io.ReaderFrom = &httpFancyWriter{}\n\n// http2FancyWriter is a HTTP2 writer that additionally satisfies\n// http.Flusher, and io.ReaderFrom. It exists for the common case\n// of wrapping the http.ResponseWriter that package http gives you, in order to\n// make the proxied object support the full method set of the proxied object.\ntype http2FancyWriter struct {\n\tbasicWriter\n}\n\nfunc (f *http2FancyWriter) Flush() {\n\tf.wroteHeader = true\n\tfl := f.basicWriter.ResponseWriter.(http.Flusher)\n\tfl.Flush()\n}\n\nvar _ http.Flusher = &http2FancyWriter{}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/mux.go",
"content": "package chi\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"strings\"\n\t\"sync\"\n)\n\nvar _ Router = &Mux{}\n\n// Mux is a simple HTTP route multiplexer that parses a request path,\n// records any URL params, and executes an end handler. It implements\n// the http.Handler interface and is friendly with the standard library.\n//\n// Mux is designed to be fast, minimal and offer a powerful API for building\n// modular and composable HTTP services with a large set of handlers. It's\n// particularly useful for writing large REST API services that break a handler\n// into many smaller parts composed of middlewares and end handlers.\ntype Mux struct {\n\t// The computed mux handler made of the chained middleware stack and\n\t// the tree router\n\thandler http.Handler\n\n\t// The radix trie router\n\ttree *node\n\n\t// Custom method not allowed handler\n\tmethodNotAllowedHandler http.HandlerFunc\n\n\t// A reference to the parent mux used by subrouters when mounting\n\t// to a parent mux\n\tparent *Mux\n\n\t// Routing context pool\n\tpool *sync.Pool\n\n\t// Custom route not found handler\n\tnotFoundHandler http.HandlerFunc\n\n\t// The middleware stack\n\tmiddlewares []func(http.Handler) http.Handler\n\n\t// Controls the behaviour of middleware chain generation when a mux\n\t// is registered as an inline group inside another mux.\n\tinline bool\n}\n\n// NewMux returns a newly initialized Mux object that implements the Router\n// interface.\nfunc NewMux() *Mux {\n\tmux := &Mux{tree: &node{}, pool: &sync.Pool{}}\n\tmux.pool.New = func() interface{} {\n\t\treturn NewRouteContext()\n\t}\n\treturn mux\n}\n\n// ServeHTTP is the single method of the http.Handler interface that makes\n// Mux interoperable with the standard library. It uses a sync.Pool to get and\n// reuse routing contexts for each request.\nfunc (mx *Mux) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n\t// Ensure the mux has some routes defined on the mux\n\tif mx.handler == nil {\n\t\tmx.NotFoundHandler().ServeHTTP(w, r)\n\t\treturn\n\t}\n\n\t// Check if a routing context already exists from a parent router.\n\trctx, _ := r.Context().Value(RouteCtxKey).(*Context)\n\tif rctx != nil {\n\t\tmx.handler.ServeHTTP(w, r)\n\t\treturn\n\t}\n\n\t// Fetch a RouteContext object from the sync pool, and call the computed\n\t// mx.handler that is comprised of mx.middlewares + mx.routeHTTP.\n\t// Once the request is finished, reset the routing context and put it back\n\t// into the pool for reuse from another request.\n\trctx = mx.pool.Get().(*Context)\n\trctx.Reset()\n\trctx.Routes = mx\n\trctx.parentCtx = r.Context()\n\n\t// NOTE: r.WithContext() causes 2 allocations and context.WithValue() causes 1 allocation\n\tr = r.WithContext(context.WithValue(r.Context(), RouteCtxKey, rctx))\n\n\t// Serve the request and once its done, put the request context back in the sync pool\n\tmx.handler.ServeHTTP(w, r)\n\tmx.pool.Put(rctx)\n}\n\n// Use appends a middleware handler to the Mux middleware stack.\n//\n// The middleware stack for any Mux will execute before searching for a matching\n// route to a specific handler, which provides opportunity to respond early,\n// change the course of the request execution, or set request-scoped values for\n// the next http.Handler.\nfunc (mx *Mux) Use(middlewares ...func(http.Handler) http.Handler) {\n\tif mx.handler != nil {\n\t\tpanic(\"chi: all middlewares must be defined before routes on a mux\")\n\t}\n\tmx.middlewares = append(mx.middlewares, middlewares...)\n}\n\n// Handle adds the route `pattern` that matches any http method to\n// execute the `handler` http.Handler.\nfunc (mx *Mux) Handle(pattern string, handler http.Handler) {\n\tparts := strings.SplitN(pattern, \" \", 2)\n\tif len(parts) == 2 {\n\t\tmx.Method(parts[0], parts[1], handler)\n\t\treturn\n\t}\n\n\tmx.handle(mALL, pattern, handler)\n}\n\n// HandleFunc adds the route `pattern` that matches any http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) HandleFunc(pattern string, handlerFn http.HandlerFunc) {\n\tparts := strings.SplitN(pattern, \" \", 2)\n\tif len(parts) == 2 {\n\t\tmx.Method(parts[0], parts[1], handlerFn)\n\t\treturn\n\t}\n\n\tmx.handle(mALL, pattern, handlerFn)\n}\n\n// Method adds the route `pattern` that matches `method` http method to\n// execute the `handler` http.Handler.\nfunc (mx *Mux) Method(method, pattern string, handler http.Handler) {\n\tm, ok := methodMap[strings.ToUpper(method)]\n\tif !ok {\n\t\tpanic(fmt.Sprintf(\"chi: '%s' http method is not supported.\", method))\n\t}\n\tmx.handle(m, pattern, handler)\n}\n\n// MethodFunc adds the route `pattern` that matches `method` http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) MethodFunc(method, pattern string, handlerFn http.HandlerFunc) {\n\tmx.Method(method, pattern, handlerFn)\n}\n\n// Connect adds the route `pattern` that matches a CONNECT http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Connect(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mCONNECT, pattern, handlerFn)\n}\n\n// Delete adds the route `pattern` that matches a DELETE http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Delete(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mDELETE, pattern, handlerFn)\n}\n\n// Get adds the route `pattern` that matches a GET http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Get(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mGET, pattern, handlerFn)\n}\n\n// Head adds the route `pattern` that matches a HEAD http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Head(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mHEAD, pattern, handlerFn)\n}\n\n// Options adds the route `pattern` that matches an OPTIONS http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Options(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mOPTIONS, pattern, handlerFn)\n}\n\n// Patch adds the route `pattern` that matches a PATCH http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Patch(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mPATCH, pattern, handlerFn)\n}\n\n// Post adds the route `pattern` that matches a POST http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Post(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mPOST, pattern, handlerFn)\n}\n\n// Put adds the route `pattern` that matches a PUT http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Put(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mPUT, pattern, handlerFn)\n}\n\n// Trace adds the route `pattern` that matches a TRACE http method to\n// execute the `handlerFn` http.HandlerFunc.\nfunc (mx *Mux) Trace(pattern string, handlerFn http.HandlerFunc) {\n\tmx.handle(mTRACE, pattern, handlerFn)\n}\n\n// NotFound sets a custom http.HandlerFunc for routing paths that could\n// not be found. The default 404 handler is `http.NotFound`.\nfunc (mx *Mux) NotFound(handlerFn http.HandlerFunc) {\n\t// Build NotFound handler chain\n\tm := mx\n\thFn := handlerFn\n\tif mx.inline && mx.parent != nil {\n\t\tm = mx.parent\n\t\thFn = Chain(mx.middlewares...).HandlerFunc(hFn).ServeHTTP\n\t}\n\n\t// Update the notFoundHandler from this point forward\n\tm.notFoundHandler = hFn\n\tm.updateSubRoutes(func(subMux *Mux) {\n\t\tif subMux.notFoundHandler == nil {\n\t\t\tsubMux.NotFound(hFn)\n\t\t}\n\t})\n}\n\n// MethodNotAllowed sets a custom http.HandlerFunc for routing paths where the\n// method is unresolved. The default handler returns a 405 with an empty body.\nfunc (mx *Mux) MethodNotAllowed(handlerFn http.HandlerFunc) {\n\t// Build MethodNotAllowed handler chain\n\tm := mx\n\thFn := handlerFn\n\tif mx.inline && mx.parent != nil {\n\t\tm = mx.parent\n\t\thFn = Chain(mx.middlewares...).HandlerFunc(hFn).ServeHTTP\n\t}\n\n\t// Update the methodNotAllowedHandler from this point forward\n\tm.methodNotAllowedHandler = hFn\n\tm.updateSubRoutes(func(subMux *Mux) {\n\t\tif subMux.methodNotAllowedHandler == nil {\n\t\t\tsubMux.MethodNotAllowed(hFn)\n\t\t}\n\t})\n}\n\n// With adds inline middlewares for an endpoint handler.\nfunc (mx *Mux) With(middlewares ...func(http.Handler) http.Handler) Router {\n\t// Similarly as in handle(), we must build the mux handler once additional\n\t// middleware registration isn't allowed for this stack, like now.\n\tif !mx.inline && mx.handler == nil {\n\t\tmx.updateRouteHandler()\n\t}\n\n\t// Copy middlewares from parent inline muxs\n\tvar mws Middlewares\n\tif mx.inline {\n\t\tmws = make(Middlewares, len(mx.middlewares))\n\t\tcopy(mws, mx.middlewares)\n\t}\n\tmws = append(mws, middlewares...)\n\n\tim := &Mux{\n\t\tpool: mx.pool, inline: true, parent: mx, tree: mx.tree, middlewares: mws,\n\t\tnotFoundHandler: mx.notFoundHandler, methodNotAllowedHandler: mx.methodNotAllowedHandler,\n\t}\n\n\treturn im\n}\n\n// Group creates a new inline-Mux with a copy of middleware stack. It's useful\n// for a group of handlers along the same routing path that use an additional\n// set of middlewares. See _examples/.\nfunc (mx *Mux) Group(fn func(r Router)) Router {\n\tim := mx.With()\n\tif fn != nil {\n\t\tfn(im)\n\t}\n\treturn im\n}\n\n// Route creates a new Mux and mounts it along the `pattern` as a subrouter.\n// Effectively, this is a short-hand call to Mount. See _examples/.\nfunc (mx *Mux) Route(pattern string, fn func(r Router)) Router {\n\tif fn == nil {\n\t\tpanic(fmt.Sprintf(\"chi: attempting to Route() a nil subrouter on '%s'\", pattern))\n\t}\n\tsubRouter := NewRouter()\n\tfn(subRouter)\n\tmx.Mount(pattern, subRouter)\n\treturn subRouter\n}\n\n// Mount attaches another http.Handler or chi Router as a subrouter along a routing\n// path. It's very useful to split up a large API as many independent routers and\n// compose them as a single service using Mount. See _examples/.\n//\n// Note that Mount() simply sets a wildcard along the `pattern` that will continue\n// routing at the `handler`, which in most cases is another chi.Router. As a result,\n// if you define two Mount() routes on the exact same pattern the mount will panic.\nfunc (mx *Mux) Mount(pattern string, handler http.Handler) {\n\tif handler == nil {\n\t\tpanic(fmt.Sprintf(\"chi: attempting to Mount() a nil handler on '%s'\", pattern))\n\t}\n\n\t// Provide runtime safety for ensuring a pattern isn't mounted on an existing\n\t// routing pattern.\n\tif mx.tree.findPattern(pattern+\"*\") || mx.tree.findPattern(pattern+\"/*\") {\n\t\tpanic(fmt.Sprintf(\"chi: attempting to Mount() a handler on an existing path, '%s'\", pattern))\n\t}\n\n\t// Assign sub-Router's with the parent not found & method not allowed handler if not specified.\n\tsubr, ok := handler.(*Mux)\n\tif ok && subr.notFoundHandler == nil && mx.notFoundHandler != nil {\n\t\tsubr.NotFound(mx.notFoundHandler)\n\t}\n\tif ok && subr.methodNotAllowedHandler == nil && mx.methodNotAllowedHandler != nil {\n\t\tsubr.MethodNotAllowed(mx.methodNotAllowedHandler)\n\t}\n\n\tmountHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\trctx := RouteContext(r.Context())\n\n\t\t// shift the url path past the previous subrouter\n\t\trctx.RoutePath = mx.nextRoutePath(rctx)\n\n\t\t// reset the wildcard URLParam which connects the subrouter\n\t\tn := len(rctx.URLParams.Keys) - 1\n\t\tif n >= 0 && rctx.URLParams.Keys[n] == \"*\" && len(rctx.URLParams.Values) > n {\n\t\t\trctx.URLParams.Values[n] = \"\"\n\t\t}\n\n\t\thandler.ServeHTTP(w, r)\n\t})\n\n\tif pattern == \"\" || pattern[len(pattern)-1] != '/' {\n\t\tmx.handle(mALL|mSTUB, pattern, mountHandler)\n\t\tmx.handle(mALL|mSTUB, pattern+\"/\", mountHandler)\n\t\tpattern += \"/\"\n\t}\n\n\tmethod := mALL\n\tsubroutes, _ := handler.(Routes)\n\tif subroutes != nil {\n\t\tmethod |= mSTUB\n\t}\n\tn := mx.handle(method, pattern+\"*\", mountHandler)\n\n\tif subroutes != nil {\n\t\tn.subroutes = subroutes\n\t}\n}\n\n// Routes returns a slice of routing information from the tree,\n// useful for traversing available routes of a router.\nfunc (mx *Mux) Routes() []Route {\n\treturn mx.tree.routes()\n}\n\n// Middlewares returns a slice of middleware handler functions.\nfunc (mx *Mux) Middlewares() Middlewares {\n\treturn mx.middlewares\n}\n\n// Match searches the routing tree for a handler that matches the method/path.\n// It's similar to routing a http request, but without executing the handler\n// thereafter.\n//\n// Note: the *Context state is updated during execution, so manage\n// the state carefully or make a NewRouteContext().\nfunc (mx *Mux) Match(rctx *Context, method, path string) bool {\n\tm, ok := methodMap[method]\n\tif !ok {\n\t\treturn false\n\t}\n\n\tnode, _, h := mx.tree.FindRoute(rctx, m, path)\n\n\tif node != nil && node.subroutes != nil {\n\t\trctx.RoutePath = mx.nextRoutePath(rctx)\n\t\treturn node.subroutes.Match(rctx, method, rctx.RoutePath)\n\t}\n\n\treturn h != nil\n}\n\n// NotFoundHandler returns the default Mux 404 responder whenever a route\n// cannot be found.\nfunc (mx *Mux) NotFoundHandler() http.HandlerFunc {\n\tif mx.notFoundHandler != nil {\n\t\treturn mx.notFoundHandler\n\t}\n\treturn http.NotFound\n}\n\n// MethodNotAllowedHandler returns the default Mux 405 responder whenever\n// a method cannot be resolved for a route.\nfunc (mx *Mux) MethodNotAllowedHandler(methodsAllowed ...methodTyp) http.HandlerFunc {\n\tif mx.methodNotAllowedHandler != nil {\n\t\treturn mx.methodNotAllowedHandler\n\t}\n\treturn methodNotAllowedHandler(methodsAllowed...)\n}\n\n// handle registers a http.Handler in the routing tree for a particular http method\n// and routing pattern.\nfunc (mx *Mux) handle(method methodTyp, pattern string, handler http.Handler) *node {\n\tif len(pattern) == 0 || pattern[0] != '/' {\n\t\tpanic(fmt.Sprintf(\"chi: routing pattern must begin with '/' in '%s'\", pattern))\n\t}\n\n\t// Build the computed routing handler for this routing pattern.\n\tif !mx.inline && mx.handler == nil {\n\t\tmx.updateRouteHandler()\n\t}\n\n\t// Build endpoint handler with inline middlewares for the route\n\tvar h http.Handler\n\tif mx.inline {\n\t\tmx.handler = http.HandlerFunc(mx.routeHTTP)\n\t\th = Chain(mx.middlewares...).Handler(handler)\n\t} else {\n\t\th = handler\n\t}\n\n\t// Add the endpoint to the tree and return the node\n\treturn mx.tree.InsertRoute(method, pattern, h)\n}\n\n// routeHTTP routes a http.Request through the Mux routing tree to serve\n// the matching handler for a particular http method.\nfunc (mx *Mux) routeHTTP(w http.ResponseWriter, r *http.Request) {\n\t// Grab the route context object\n\trctx := r.Context().Value(RouteCtxKey).(*Context)\n\n\t// The request routing path\n\troutePath := rctx.RoutePath\n\tif routePath == \"\" {\n\t\tif r.URL.RawPath != \"\" {\n\t\t\troutePath = r.URL.RawPath\n\t\t} else {\n\t\t\troutePath = r.URL.Path\n\t\t}\n\t\tif routePath == \"\" {\n\t\t\troutePath = \"/\"\n\t\t}\n\t}\n\n\t// Check if method is supported by chi\n\tif rctx.RouteMethod == \"\" {\n\t\trctx.RouteMethod = r.Method\n\t}\n\tmethod, ok := methodMap[rctx.RouteMethod]\n\tif !ok {\n\t\tmx.MethodNotAllowedHandler().ServeHTTP(w, r)\n\t\treturn\n\t}\n\n\t// Find the route\n\tif _, _, h := mx.tree.FindRoute(rctx, method, routePath); h != nil {\n\t\tif supportsPathValue {\n\t\t\tsetPathValue(rctx, r)\n\t\t}\n\n\t\th.ServeHTTP(w, r)\n\t\treturn\n\t}\n\tif rctx.methodNotAllowed {\n\t\tmx.MethodNotAllowedHandler(rctx.methodsAllowed...).ServeHTTP(w, r)\n\t} else {\n\t\tmx.NotFoundHandler().ServeHTTP(w, r)\n\t}\n}\n\nfunc (mx *Mux) nextRoutePath(rctx *Context) string {\n\troutePath := \"/\"\n\tnx := len(rctx.routeParams.Keys) - 1 // index of last param in list\n\tif nx >= 0 && rctx.routeParams.Keys[nx] == \"*\" && len(rctx.routeParams.Values) > nx {\n\t\troutePath = \"/\" + rctx.routeParams.Values[nx]\n\t}\n\treturn routePath\n}\n\n// Recursively update data on child routers.\nfunc (mx *Mux) updateSubRoutes(fn func(subMux *Mux)) {\n\tfor _, r := range mx.tree.routes() {\n\t\tsubMux, ok := r.SubRoutes.(*Mux)\n\t\tif !ok {\n\t\t\tcontinue\n\t\t}\n\t\tfn(subMux)\n\t}\n}\n\n// updateRouteHandler builds the single mux handler that is a chain of the middleware\n// stack, as defined by calls to Use(), and the tree router (Mux) itself. After this\n// point, no other middlewares can be registered on this Mux's stack. But you can still\n// compose additional middlewares via Group()'s or using a chained middleware handler.\nfunc (mx *Mux) updateRouteHandler() {\n\tmx.handler = chain(mx.middlewares, http.HandlerFunc(mx.routeHTTP))\n}\n\n// methodNotAllowedHandler is a helper function to respond with a 405,\n// method not allowed. It sets the Allow header with the list of allowed\n// methods for the route.\nfunc methodNotAllowedHandler(methodsAllowed ...methodTyp) func(w http.ResponseWriter, r *http.Request) {\n\treturn func(w http.ResponseWriter, r *http.Request) {\n\t\tfor _, m := range methodsAllowed {\n\t\t\tw.Header().Add(\"Allow\", reverseMethodMap[m])\n\t\t}\n\t\tw.WriteHeader(405)\n\t\tw.Write(nil)\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/path_value.go",
"content": "//go:build go1.22\n// +build go1.22\n\npackage chi\n\nimport \"net/http\"\n\n// supportsPathValue is true if the Go version is 1.22 and above.\n//\n// If this is true, `net/http.Request` has methods `SetPathValue` and `PathValue`.\nconst supportsPathValue = true\n\n// setPathValue sets the path values in the Request value\n// based on the provided request context.\nfunc setPathValue(rctx *Context, r *http.Request) {\n\tfor i, key := range rctx.URLParams.Keys {\n\t\tvalue := rctx.URLParams.Values[i]\n\t\tr.SetPathValue(key, value)\n\t}\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/path_value_fallback.go",
"content": "//go:build !go1.22\n// +build !go1.22\n\npackage chi\n\nimport \"net/http\"\n\n// supportsPathValue is true if the Go version is 1.22 and above.\n//\n// If this is true, `net/http.Request` has methods `SetPathValue` and `PathValue`.\nconst supportsPathValue = false\n\n// setPathValue sets the path values in the Request value\n// based on the provided request context.\n//\n// setPathValue is only supported in Go 1.22 and above so\n// this is just a blank function so that it compiles.\nfunc setPathValue(rctx *Context, r *http.Request) {\n}\n"
},
{
"path": "vendor/github.com/go-chi/chi/v5/tree.go",
"content": "package chi\n\n// Radix tree implementation below is a based on the original work by\n// Armon Dadgar in https://github.com/armon/go-radix/blob/master/radix.go\n// (MIT licensed). It's been heavily modified for use as a HTTP routing tree.\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"regexp\"\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n)\n\ntype methodTyp uint\n\nconst (\n\tmSTUB methodTyp = 1 << iota\n\tmCONNECT\n\tmDELETE\n\tmGET\n\tmHEAD\n\tmOPTIONS\n\tmPATCH\n\tmPOST\n\tmPUT\n\tmTRACE\n)\n\nvar mALL = mCONNECT | mDELETE | mGET | mHEAD |\n\tmOPTIONS | mPATCH | mPOST | mPUT | mTRACE\n\nvar methodMap = map[string]methodTyp{\n\thttp.MethodConnect: mCONNECT,\n\thttp.MethodDelete: mDELETE,\n\thttp.MethodGet: mGET,\n\thttp.MethodHead: mHEAD,\n\thttp.MethodOptions: mOPTIONS,\n\thttp.MethodPatch: mPATCH,\n\thttp.MethodPost: mPOST,\n\thttp.MethodPut: mPUT,\n\thttp.MethodTrace: mTRACE,\n}\n\nvar reverseMethodMap = map[methodTyp]string{\n\tmCONNECT: http.MethodConnect,\n\tmDELETE: http.MethodDelete,\n\tmGET: http.MethodGet,\n\tmHEAD: http.MethodHead,\n\tmOPTIONS: http.MethodOptions,\n\tmPATCH: http.MethodPatch,\n\tmPOST: http.MethodPost,\n\tmPUT: http.MethodPut,\n\tmTRACE: http.MethodTrace,\n}\n\n// RegisterMethod adds support for custom HTTP method handlers, available\n// via Router#Method and Router#MethodFunc\nfunc RegisterMethod(method string) {\n\tif method == \"\" {\n\t\treturn\n\t}\n\tmethod = strings.ToUpper(method)\n\tif _, ok := methodMap[method]; ok {\n\t\treturn\n\t}\n\tn := len(methodMap)\n\tif n > strconv.IntSize-2 {\n\t\tpanic(fmt.Sprintf(\"chi: max number of methods reached (%d)\", strconv.IntSize))\n\t}\n\tmt := methodTyp(2 << n)\n\tmethodMap[method] = mt\n\tmALL |= mt\n}\n\ntype nodeTyp uint8\n\nconst (\n\tntStatic nodeTyp = iota // /home\n\tntRegexp // /{id:[0-9]+}\n\tntParam // /{user}\n\tntCatchAll // /api/v1/*\n)\n\ntype node struct {\n\t// subroutes on the leaf node\n\tsubroutes Routes\n\n\t// regexp matcher for regexp nodes\n\trex *regexp.Regexp\n\n\t// HTTP handler endpoints on the leaf node\n\tendpoints endpoints\n\n\t// prefix is the common prefix we ignore\n\tprefix string\n\n\t// child nodes should be stored in-order for iteration,\n\t// in groups of the node type.\n\tchildren [ntCatchAll + 1]nodes\n\n\t// first byte of the child prefix\n\ttail byte\n\n\t// node type: static, regexp, param, catchAll\n\ttyp nodeTyp\n\n\t// first byte of the prefix\n\tlabel byte\n}\n\n// endpoints is a mapping of http method constants to handlers\n// for a given route.\ntype endpoints map[methodTyp]*endpoint\n\ntype endpoint struct {\n\t// endpoint handler\n\thandler http.Handler\n\n\t// pattern is the routing pattern for handler nodes\n\tpattern string\n\n\t// parameter keys recorded on handler nodes\n\tparamKeys []string\n}\n\nfunc (s endpoints) Value(method methodTyp) *endpoint {\n\tmh, ok := s[method]\n\tif !ok {\n\t\tmh = &endpoint{}\n\t\ts[method] = mh\n\t}\n\treturn mh\n}\n\nfunc (n *node) InsertRoute(method methodTyp, pattern string, handler http.Handler) *node {\n\tvar parent *node\n\tsearch := pattern\n\n\tfor {\n\t\t// Handle key exhaustion\n\t\tif len(search) == 0 {\n\t\t\t// Insert or update the node's leaf handler\n\t\t\tn.setEndpoint(method, handler, pattern)\n\t\t\treturn n\n\t\t}\n\n\t\t// We're going to be searching for a wild node next,\n\t\t// in this case, we need to get the tail\n\t\tvar label = search[0]\n\t\tvar segTail byte\n\t\tvar segEndIdx int\n\t\tvar segTyp nodeTyp\n\t\tvar segRexpat string\n\t\tif label == '{' || label == '*' {\n\t\t\tsegTyp, _, segRexpat, segTail, _, segEndIdx = patNextSegment(search)\n\t\t}\n\n\t\tvar prefix string\n\t\tif segTyp == ntRegexp {\n\t\t\tprefix = segRexpat\n\t\t}\n\n\t\t// Look for the edge to attach to\n\t\tparent = n\n\t\tn = n.getEdge(segTyp, label, segTail, prefix)\n\n\t\t// No edge, create one\n\t\tif n == nil {\n\t\t\tchild := &node{label: label, tail: segTail, prefix: search}\n\t\t\thn := parent.addChild(child, search)\n\t\t\thn.setEndpoint(method, handler, pattern)\n\n\t\t\treturn hn\n\t\t}\n\n\t\t// Found an edge to match the pattern\n\n\t\tif n.typ > ntStatic {\n\t\t\t// We found a param node, trim the param from the search path and continue.\n\t\t\t// This param/wild pattern segment would already be on the tree from a previous\n\t\t\t// call to addChild when creating a new node.\n\t\t\tsearch = search[segEndIdx:]\n\t\t\tcontinue\n\t\t}\n\n\t\t// Static nodes fall below here.\n\t\t// Determine longest prefix of the search key on match.\n\t\tcommonPrefix := longestPrefix(search, n.prefix)\n\t\tif commonPrefix == len(n.prefix) {\n\t\t\t// the common prefix is as long as the current node's prefix we're attempting to insert.\n\t\t\t// keep the search going.\n\t\t\tsearch = search[commonPrefix:]\n\t\t\tcontinue\n\t\t}\n\n\t\t// Split the node\n\t\tchild := &node{\n\t\t\ttyp: ntStatic,\n\t\t\tprefix: search[:commonPrefix],\n\t\t}\n\t\tparent.replaceChild(search[0], segTail, child)\n\n\t\t// Restore the existing node\n\t\tn.label = n.prefix[commonPrefix]\n\t\tn.prefix = n.prefix[commonPrefix:]\n\t\tchild.addChild(n, n.prefix)\n\n\t\t// If the new key is a subset, set the method/handler on this node and finish.\n\t\tsearch = search[commonPrefix:]\n\t\tif len(search) == 0 {\n\t\t\tchild.setEndpoint(method, handler, pattern)\n\t\t\treturn child\n\t\t}\n\n\t\t// Create a new edge for the node\n\t\tsubchild := &node{\n\t\t\ttyp: ntStatic,\n\t\t\tlabel: search[0],\n\t\t\tprefix: search,\n\t\t}\n\t\thn := child.addChild(subchild, search)\n\t\thn.setEndpoint(method, handler, pattern)\n\t\treturn hn\n\t}\n}\n\n// addChild appends the new `child` node to the tree using the `pattern` as the trie key.\n// For a URL router like chi's, we split the static, param, regexp and wildcard segments\n// into different nodes. In addition, addChild will recursively call itself until every\n// pattern segment is added to the url pattern tree as individual nodes, depending on type.\nfunc (n *node) addChild(child *node, prefix string) *node {\n\tsearch := prefix\n\n\t// handler leaf node added to the tree is the child.\n\t// this may be overridden later down the flow\n\thn := child\n\n\t// Parse next segment\n\tsegTyp, _, segRexpat, segTail, segStartIdx, segEndIdx := patNextSegment(search)\n\n\t// Add child depending on next up segment\n\tswitch segTyp {\n\n\tcase ntStatic:\n\t\t// Search prefix is all static (that is, has no params in path)\n\t\t// noop\n\n\tdefault:\n\t\t// Search prefix contains a param, regexp or wildcard\n\n\t\tif segTyp == ntRegexp {\n\t\t\trex, err := regexp.Compile(segRexpat)\n\t\t\tif err != nil {\n\t\t\t\tpanic(fmt.Sprintf(\"chi: invalid regexp pattern '%s' in route param\", segRexpat))\n\t\t\t}\n\t\t\tchild.prefix = segRexpat\n\t\t\tchild.rex = rex\n\t\t}\n\n\t\tif segStartIdx == 0 {\n\t\t\t// Route starts with a param\n\t\t\tchild.typ = segTyp\n\n\t\t\tif segTyp == ntCatchAll {\n\t\t\t\tsegStartIdx = -1\n\t\t\t} else {\n\t\t\t\tsegStartIdx = segEndIdx\n\t\t\t}\n\t\t\tif segStartIdx < 0 {\n\t\t\t\tsegStartIdx = len(search)\n\t\t\t}\n\t\t\tchild.tail = segTail // for params, we set the tail\n\n\t\t\tif segStartIdx != len(search) {\n\t\t\t\t// add static edge for the remaining part, split the end.\n\t\t\t\t// its not possible to have adjacent param nodes, so its certainly\n\t\t\t\t// going to be a static node next.\n\n\t\t\t\tsearch = search[segStartIdx:] // advance search position\n\n\t\t\t\tnn := &node{\n\t\t\t\t\ttyp: ntStatic,\n\t\t\t\t\tlabel: search[0],\n\t\t\t\t\tprefix: search,\n\t\t\t\t}\n\t\t\t\thn = child.addChild(nn, search)\n\t\t\t}\n\n\t\t} else if segStartIdx > 0 {\n\t\t\t// Route has some param\n\n\t\t\t// starts with a static segment\n\t\t\tchild.typ = ntStatic\n\t\t\tchild.prefix = search[:segStartIdx]\n\t\t\tchild.rex = nil\n\n\t\t\t// add the param edge node\n\t\t\tsearch = search[segStartIdx:]\n\n\t\t\tnn := &node{\n\t\t\t\ttyp: segTyp,\n\t\t\t\tlabel: search[0],\n\t\t\t\ttail: segTail,\n\t\t\t}\n\t\t\thn = child.addChild(nn, search)\n\n\t\t}\n\t}\n\n\tn.children[child.typ] = append(n.children[child.typ], child)\n\tn.children[child.typ].Sort()\n\treturn hn\n}\n\nfunc (n *node) replaceChild(label, tail byte, child *node) {\n\tfor i := 0; i < len(n.children[child.typ]); i++ {\n\t\tif n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail {\n\t\t\tn.children[child.typ][i] = child\n\t\t\tn.children[child.typ][i].label = label\n\t\t\tn.children[child.typ][i].tail = tail\n\t\t\treturn\n\t\t}\n\t}\n\tpanic(\"chi: replacing missing child\")\n}\n\nfunc (n *node) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *node {\n\tnds := n.children[ntyp]\n\tfor i := 0; i < len(nds); i++ {\n\t\tif nds[i].label == label && nds[i].tail == tail {\n\t\t\tif ntyp == ntRegexp && nds[i].prefix != prefix {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\treturn nds[i]\n\t\t}\n\t}\n\treturn nil\n}\n\nfunc (n *node) setEndpoint(method methodTyp, handler http.Handler, pattern string) {\n\t// Set the handler for the method type on the node\n\tif n.endpoints == nil {\n\t\tn.endpoints = make(endpoints)\n\t}\n\n\tparamKeys := patParamKeys(pattern)\n\n\tif method&mSTUB == mSTUB {\n\t\tn.endpoints.Value(mSTUB).handler = handler\n\t}\n\tif method&mALL == mALL {\n\t\th := n.endpoints.Value(mALL)\n\t\th.handler = handler\n\t\th.pattern = pattern\n\t\th.paramKeys = paramKeys\n\t\tfor _, m := range methodMap {\n\t\t\th := n.endpoints.Value(m)\n\t\t\th.handler = handler\n\t\t\th.pattern = pattern\n\t\t\th.paramKeys = paramKeys\n\t\t}\n\t} else {\n\t\th := n.endpoints.Value(method)\n\t\th.handler = handler\n\t\th.pattern = pattern\n\t\th.paramKeys = paramKeys\n\t}\n}\n\nfunc (n *node) FindRoute(rctx *Context, method methodTyp, path string) (*node, endpoints, http.Handler) {\n\t// Reset the context routing pattern and params\n\trctx.routePattern = \"\"\n\trctx.routeParams.Keys = rctx.routeParams.Keys[:0]\n\trctx.routeParams.Values = rctx.routeParams.Values[:0]\n\n\t// Find the routing handlers for the path\n\trn := n.findRoute(rctx, method, path)\n\tif rn == nil {\n\t\treturn nil, nil, nil\n\t}\n\n\t// Record the routing params in the request lifecycle\n\trctx.URLParams.Keys = append(rctx.URLParams.Keys, rctx.routeParams.Keys...)\n\trctx.URLParams.Values = append(rctx.URLParams.Values, rctx.routeParams.Values...)\n\n\t// Record the routing pattern in the request lifecycle\n\tif rn.endpoints[method].pattern != \"\" {\n\t\trctx.routePattern = rn.endpoints[method].pattern\n\t\trctx.RoutePatterns = append(rctx.RoutePatterns, rctx.routePattern)\n\t}\n\n\treturn rn, rn.endpoints, rn.endpoints[method].handler\n}\n\n// Recursive edge traversal by checking all nodeTyp groups along the way.\n// It's like searching through a multi-dimensional radix trie.\nfunc (n *node) findRoute(rctx *Context, method methodTyp, path string) *node {\n\tnn := n\n\tsearch := path\n\n\tfor t, nds := range nn.children {\n\t\tntyp := nodeTyp(t)\n\t\tif len(nds) == 0 {\n\t\t\tcontinue\n\t\t}\n\n\t\tvar xn *node\n\t\txsearch := search\n\n\t\tvar label byte\n\t\tif search != \"\" {\n\t\t\tlabel = search[0]\n\t\t}\n\n\t\tswitch ntyp {\n\t\tcase ntStatic:\n\t\t\txn = nds.findEdge(label)\n\t\t\tif xn == nil || !strings.HasPrefix(xsearch, xn.prefix) {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\txsearch = xsearch[len(xn.prefix):]\n\n\t\tcase ntParam, ntRegexp:\n\t\t\t// short-circuit and return no matching route for empty param values\n\t\t\tif xsearch == \"\" {\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\t// serially loop through each node grouped by the tail delimiter\n\t\t\tfor idx := 0; idx < len(nds); idx++ {\n\t\t\t\txn = nds[idx]\n\n\t\t\t\t// label for param nodes is the delimiter byte\n\t\t\t\tp := strings.IndexByte(xsearch, xn.tail)\n\n\t\t\t\tif p < 0 {\n\t\t\t\t\tif xn.tail == '/' {\n\t\t\t\t\t\tp = len(xsearch)\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcontinue\n\t\t\t\t\t}\n\t\t\t\t} else if ntyp == ntRegexp && p == 0 {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\tif ntyp == ntRegexp && xn.rex != nil {\n\t\t\t\t\tif !xn.rex.MatchString(xsearch[:p]) {\n\t\t\t\t\t\tcontinue\n\t\t\t\t\t}\n\t\t\t\t} else if strings.IndexByte(xsearch[:p], '/') != -1 {\n\t\t\t\t\t// avoid a match across path segments\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\n\t\t\t\tprevlen := len(rctx.routeParams.Values)\n\t\t\t\trctx.routeParams.Values = append(rctx.routeParams.Values, xsearch[:p])\n\t\t\t\txsearch = xsearch[p:]\n\n\t\t\t\tif len(xsearch) == 0 {\n\t\t\t\t\tif xn.isLeaf() {\n\t\t\t\t\t\th := xn.endpoints[method]\n\t\t\t\t\t\tif h != nil && h.handler != nil {\n\t\t\t\t\t\t\trctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...)\n\t\t\t\t\t\t\treturn xn\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tfor endpoints := range xn.endpoints {\n\t\t\t\t\t\t\tif endpoints == mALL || endpoints == mSTUB {\n\t\t\t\t\t\t\t\tcontinue\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\trctx.methodsAllowed = append(rctx.methodsAllowed, endpoints)\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// flag that the routing context found a route, but not a corresponding\n\t\t\t\t\t\t// supported method\n\t\t\t\t\t\trctx.methodNotAllowed = true\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// recursively find the next node on this branch\n\t\t\t\tfin := xn.findRoute(rctx, method, xsearch)\n\t\t\t\tif fin != nil {\n\t\t\t\t\treturn fin\n\t\t\t\t}\n\n\t\t\t\t// not found on this branch, reset vars\n\t\t\t\trctx.routeParams.Values = rctx.routeParams.Values[:prevlen]\n\t\t\t\txsearch = search\n\t\t\t}\n\n\t\t\trctx.routeParams.Values = append(rctx.routeParams.Values, \"\")\n\n\t\tdefault:\n\t\t\t// catch-all nodes\n\t\t\trctx.routeParams.Values = append(rctx.routeParams.Values, search)\n\t\t\txn = nds[0]\n\t\t\txsearch = \"\"\n\t\t}\n\n\t\tif xn == nil {\n\t\t\tcontinue\n\t\t}\n\n\t\t// did we find it yet?\n\t\tif len(xsearch) == 0 {\n\t\t\tif xn.isLeaf() {\n\t\t\t\th := xn.endpoints[method]\n\t\t\t\tif h != nil && h.handler != nil {\n\t\t\t\t\trctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...)\n\t\t\t\t\treturn xn\n\t\t\t\t}\n\n\t\t\t\tfor endpoints := range xn.endpoints {\n\t\t\t\t\tif endpoints == mALL || endpoints == mSTUB {\n\t\t\t\t\t\tcontinue\n\t\t\t\t\t}\n\t\t\t\t\trctx.methodsAllowed = append(rctx.methodsAllowed, endpoints)\n\t\t\t\t}\n\n\t\t\t\t// flag that the routing context found a route, but not a corresponding\n\t\t\t\t// supported method\n\t\t\t\trctx.methodNotAllowed = true\n\t\t\t}\n\t\t}\n\n\t\t// recursively find the next node..\n\t\tfin := xn.findRoute(rctx, method, xsearch)\n\t\tif fin != nil {\n\t\t\treturn fin\n\t\t}\n\n\t\t// Did not find final handler, let's remove the param here if it was set\n\t\tif xn.typ > ntStatic {\n\t\t\tif len(rctx.routeParams.Values) > 0 {\n\t\t\t\trctx.routeParams.Values = rctx.routeParams.Values[:len(rctx.routeParams.Values)-1]\n\t\t\t}\n\t\t}\n\n\t}\n\n\treturn nil\n}\n\nfunc (n *node) findEdge(ntyp nodeTyp, label byte) *node {\n\tnds := n.children[ntyp]\n\tnum := len(nds)\n\tidx := 0\n\n\tswitch ntyp {\n\tcase ntStatic, ntParam, ntRegexp:\n\t\ti, j := 0, num-1\n\t\tfor i <= j {\n\t\t\tidx = i + (j-i)/2\n\t\t\tif label > nds[idx].label {\n\t\t\t\ti = idx + 1\n\t\t\t} else if label < nds[idx].label {\n\t\t\t\tj = idx - 1\n\t\t\t} else {\n\t\t\t\ti = num // breaks cond\n\t\t\t}\n\t\t}\n\t\tif nds[idx].label != label {\n\t\t\treturn nil\n\t\t}\n\t\treturn nds[idx]\n\n\tdefault: // catch all\n\t\treturn nds[idx]\n\t}\n}\n\nfunc (n *node) isLeaf() bool {\n\treturn n.endpoints != nil\n}\n\nfunc (n *node) findPattern(pattern string) bool {\n\tnn := n\n\tfor _, nds := range nn.children {\n\t\tif len(nds) == 0 {\n\t\t\tcontinue\n\t\t}\n\n\t\tn = nn.findEdge(nds[0].typ, pattern[0])\n\t\tif n == nil {\n\t\t\tcontinue\n\t\t}\n\n\t\tvar idx int\n\t\tvar xpattern string\n\n\t\tswitch n.typ {\n\t\tcase ntStatic:\n\t\t\tidx = longestPrefix(pattern, n.prefix)\n\t\t\tif idx < len(n.prefix) {\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\tcase ntParam, ntRegexp:\n\t\t\tidx = strings.IndexByte(pattern, '}') + 1\n\n\t\tcase ntCatchAll:\n\t\t\tidx = longestPrefix(pattern, \"*\")\n\n\t\tdefault:\n\t\t\tpanic(\"chi: unknown node type\")\n\t\t}\n\n\t\txpattern = pattern[idx:]\n\t\tif len(xpattern) == 0 {\n\t\t\treturn true\n\t\t}\n\n\t\treturn n.findPattern(xpattern)\n\t}\n\treturn false\n}\n\nfunc (n *node) routes() []Route {\n\trts := []Route{}\n\n\tn.walk(func(eps endpoints, subroutes Routes) bool {\n\t\tif eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil {\n\t\t\treturn false\n\t\t}\n\n\t\t// Group methodHandlers by unique patterns\n\t\tpats := make(map[string]endpoints)\n\n\t\tfor mt, h := range eps {\n\t\t\tif h.pattern == \"\" {\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tp, ok := pats[h.pattern]\n\t\t\tif !ok {\n\t\t\t\tp = endpoints{}\n\t\t\t\tpats[h.pattern] = p\n\t\t\t}\n\t\t\tp[mt] = h\n\t\t}\n\n\t\tfor p, mh := range pats {\n\t\t\ths := make(map[string]http.Handler)\n\t\t\tif mh[mALL] != nil && mh[mALL].handler != nil {\n\t\t\t\ths[\"*\"] = mh[mALL].handler\n\t\t\t}\n\n\t\t\tfor mt, h := range mh {\n\t\t\t\tif h.handler == nil {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tm := methodTypString(mt)\n\t\t\t\tif m == \"\" {\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\ths[m] = h.handler\n\t\t\t}\n\n\t\t\trt := Route{subroutes, hs, p}\n\t\t\trts = append(rts, rt)\n\t\t}\n\n\t\treturn false\n\t})\n\n\treturn rts\n}\n\nfunc (n *node) walk(fn func(eps endpoints, subroutes Routes) bool) bool {\n\t// Visit the leaf values if any\n\tif (n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes) {\n\t\treturn true\n\t}\n\n\t// Recurse on the children\n\tfor _, ns := range n.children {\n\t\tfor _, cn := range ns {\n\t\t\tif cn.walk(fn) {\n\t\t\t\treturn true\n\t\t\t}\n\t\t}\n\t}\n\treturn false\n}\n\n// patNextSegment returns the next segment details from a pattern:\n// node type, param key, regexp string, param tail byte, param starting index, param ending index\nfunc patNextSegment(pattern string) (nodeTyp, string, string, byte, int, int) {\n\tps := strings.Index(pattern, \"{\")\n\tws := strings.Index(pattern, \"*\")\n\n\tif ps < 0 && ws < 0 {\n\t\treturn ntStatic, \"\", \"\", 0, 0, len(pattern) // we return the entire thing\n\t}\n\n\t// Sanity check\n\tif ps >= 0 && ws >= 0 && ws < ps {\n\t\tpanic(\"chi: wildcard '*' must be the last pattern in a route, otherwise use a '{param}'\")\n\t}\n\n\tvar tail byte = '/' // Default endpoint tail to / byte\n\n\tif ps >= 0 {\n\t\t// Param/Regexp pattern is next\n\t\tnt := ntParam\n\n\t\t// Read to closing } taking into account opens and closes in curl count (cc)\n\t\tcc := 0\n\t\tpe := ps\n\t\tfor i, c := range pattern[ps:] {\n\t\t\tif c == '{' {\n\t\t\t\tcc++\n\t\t\t} else if c == '}' {\n\t\t\t\tcc--\n\t\t\t\tif cc == 0 {\n\t\t\t\t\tpe = ps + i\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif pe == ps {\n\t\t\tpanic(\"chi: route param closing delimiter '}' is missing\")\n\t\t}\n\n\t\tkey := pattern[ps+1 : pe]\n\t\tpe++ // set end to next position\n\n\t\tif pe < len(pattern) {\n\t\t\ttail = pattern[pe]\n\t\t}\n\n\t\tvar rexpat string\n\t\tif idx := strings.Index(key, \":\"); idx >= 0 {\n\t\t\tnt = ntRegexp\n\t\t\trexpat = key[idx+1:]\n\t\t\tkey = key[:idx]\n\t\t}\n\n\t\tif len(rexpat) > 0 {\n\t\t\tif rexpat[0] != '^' {\n\t\t\t\trexpat = \"^\" + rexpat\n\t\t\t}\n\t\t\tif rexpat[len(rexpat)-1] != '$' {\n\t\t\t\trexpat += \"$\"\n\t\t\t}\n\t\t}\n\n\t\treturn nt, key, rexpat, tail, ps, pe\n\t}\n\n\t// Wildcard pattern as finale\n\tif ws < len(pattern)-1 {\n\t\tpanic(\"chi: wildcard '*' must be the last value in a route. trim trailing text or use a '{param}' instead\")\n\t}\n\treturn ntCatchAll, \"*\", \"\", 0, ws, len(pattern)\n}\n\nfunc patParamKeys(pattern string) []string {\n\tpat := pattern\n\tparamKeys := []string{}\n\tfor {\n\t\tptyp, paramKey, _, _, _, e := patNextSegment(pat)\n\t\tif ptyp == ntStatic {\n\t\t\treturn paramKeys\n\t\t}\n\t\tfor i := 0; i < len(paramKeys); i++ {\n\t\t\tif paramKeys[i] == paramKey {\n\t\t\t\tpanic(fmt.Sprintf(\"chi: routing pattern '%s' contains duplicate param key, '%s'\", pattern, paramKey))\n\t\t\t}\n\t\t}\n\t\tparamKeys = append(paramKeys, paramKey)\n\t\tpat = pat[e:]\n\t}\n}\n\n// longestPrefix finds the length of the shared prefix\n// of two strings\nfunc longestPrefix(k1, k2 string) int {\n\tmax := len(k1)\n\tif l := len(k2); l < max {\n\t\tmax = l\n\t}\n\tvar i int\n\tfor i = 0; i < max; i++ {\n\t\tif k1[i] != k2[i] {\n\t\t\tbreak\n\t\t}\n\t}\n\treturn i\n}\n\nfunc methodTypString(method methodTyp) string {\n\tfor s, t := range methodMap {\n\t\tif method == t {\n\t\t\treturn s\n\t\t}\n\t}\n\treturn \"\"\n}\n\ntype nodes []*node\n\n// Sort the list of nodes by label\nfunc (ns nodes) Sort() { sort.Sort(ns); ns.tailSort() }\nfunc (ns nodes) Len() int { return len(ns) }\nfunc (ns nodes) Swap(i, j int) { ns[i], ns[j] = ns[j], ns[i] }\nfunc (ns nodes) Less(i, j int) bool { return ns[i].label < ns[j].label }\n\n// tailSort pushes nodes with '/' as the tail to the end of the list for param nodes.\n// The list order determines the traversal order.\nfunc (ns nodes) tailSort() {\n\tfor i := len(ns) - 1; i >= 0; i-- {\n\t\tif ns[i].typ > ntStatic && ns[i].tail == '/' {\n\t\t\tns.Swap(i, len(ns)-1)\n\t\t\treturn\n\t\t}\n\t}\n}\n\nfunc (ns nodes) findEdge(label byte) *node {\n\tnum := len(ns)\n\tidx := 0\n\ti, j := 0, num-1\n\tfor i <= j {\n\t\tidx = i + (j-i)/2\n\t\tif label > ns[idx].label {\n\t\t\ti = idx + 1\n\t\t} else if label < ns[idx].label {\n\t\t\tj = idx - 1\n\t\t} else {\n\t\t\ti = num // breaks cond\n\t\t}\n\t}\n\tif ns[idx].label != label {\n\t\treturn nil\n\t}\n\treturn ns[idx]\n}\n\n// Route describes the details of a routing handler.\n// Handlers map key is an HTTP method\ntype Route struct {\n\tSubRoutes Routes\n\tHandlers map[string]http.Handler\n\tPattern string\n}\n\n// WalkFunc is the type of the function called for each method and route visited by Walk.\ntype WalkFunc func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error\n\n// Walk walks any router tree that implements Routes interface.\nfunc Walk(r Routes, walkFn WalkFunc) error {\n\treturn walk(r, walkFn, \"\")\n}\n\nfunc walk(r Routes, walkFn WalkFunc, parentRoute string, parentMw ...func(http.Handler) http.Handler) error {\n\tfor _, route := range r.Routes() {\n\t\tmws := make([]func(http.Handler) http.Handler, len(parentMw))\n\t\tcopy(mws, parentMw)\n\t\tmws = append(mws, r.Middlewares()...)\n\n\t\tif route.SubRoutes != nil {\n\t\t\tif err := walk(route.SubRoutes, walkFn, parentRoute+route.Pattern, mws...); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tcontinue\n\t\t}\n\n\t\tfor method, handler := range route.Handlers {\n\t\t\tif method == \"*\" {\n\t\t\t\t// Ignore a \"catchAll\" method, since we pass down all the specific methods for each route.\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\tfullRoute := parentRoute + route.Pattern\n\t\t\tfullRoute = strings.Replace(fullRoute, \"/*/\", \"/\", -1)\n\n\t\t\tif chain, ok := handler.(*ChainHandler); ok {\n\t\t\t\tif err := walkFn(method, fullRoute, chain.Endpoint, append(mws, chain.Middlewares...)...); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif err := walkFn(method, fullRoute, handler, mws...); err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/.gitignore",
"content": "# Binaries for programs and plugins\n*.exe\n*.exe~\n*.dll\n*.so\n*.dylib\n\n# Test binary, build with `go test -c`\n*.test\n\n# Output of the go coverage tool, specifically when used with LiteIDE\n*.out\n\n# binary bundle generated by go-fuzz\nuuid-fuzz.zip\n"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/LICENSE",
"content": "Copyright (C) 2013-2018 by Maxim Bublis \n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/README.md",
"content": "# UUID\n\n[](https://github.com/gofrs/uuid/blob/master/LICENSE)\n[](https://travis-ci.org/gofrs/uuid)\n[](http://godoc.org/github.com/gofrs/uuid)\n[](https://codecov.io/gh/gofrs/uuid/)\n[](https://goreportcard.com/report/github.com/gofrs/uuid)\n\nPackage uuid provides a pure Go implementation of Universally Unique Identifiers\n(UUID) variant as defined in RFC-4122. This package supports both the creation\nand parsing of UUIDs in different formats.\n\nThis package supports the following UUID versions:\n* Version 1, based on timestamp and MAC address (RFC-4122)\n* Version 3, based on MD5 hashing of a named value (RFC-4122)\n* Version 4, based on random numbers (RFC-4122)\n* Version 5, based on SHA-1 hashing of a named value (RFC-4122)\n\nThis package also supports experimental Universally Unique Identifier implementations based on a\n[draft RFC](https://www.ietf.org/archive/id/draft-peabody-dispatch-new-uuid-format-04.html) that updates RFC-4122\n* Version 6, a k-sortable id based on timestamp, and field-compatible with v1 (draft-peabody-dispatch-new-uuid-format, RFC-4122)\n* Version 7, a k-sortable id based on timestamp (draft-peabody-dispatch-new-uuid-format, RFC-4122)\n\nThe v6 and v7 IDs are **not** considered a part of the stable API, and may be subject to behavior or API changes as part of minor releases\nto this package. They will be updated as the draft RFC changes, and will become stable if and when the draft RFC is accepted.\n\n## Project History\n\nThis project was originally forked from the\n[github.com/satori/go.uuid](https://github.com/satori/go.uuid) repository after\nit appeared to be no longer maintained, while exhibiting [critical\nflaws](https://github.com/satori/go.uuid/issues/73). We have decided to take\nover this project to ensure it receives regular maintenance for the benefit of\nthe larger Go community.\n\nWe'd like to thank Maxim Bublis for his hard work on the original iteration of\nthe package.\n\n## License\n\nThis source code of this package is released under the MIT License. Please see\nthe [LICENSE](https://github.com/gofrs/uuid/blob/master/LICENSE) for the full\ncontent of the license.\n\n## Recommended Package Version\n\nWe recommend using v2.0.0+ of this package, as versions prior to 2.0.0 were\ncreated before our fork of the original package and have some known\ndeficiencies.\n\n## Requirements\n\nThis package requres Go 1.17 or later\n\n## Usage\n\nHere is a quick overview of how to use this package. For more detailed\ndocumentation, please see the [GoDoc Page](http://godoc.org/github.com/gofrs/uuid).\n\n```go\npackage main\n\nimport (\n\t\"log\"\n\n\t\"github.com/gofrs/uuid\"\n)\n\n// Create a Version 4 UUID, panicking on error.\n// Use this form to initialize package-level variables.\nvar u1 = uuid.Must(uuid.NewV4())\n\nfunc main() {\n\t// Create a Version 4 UUID.\n\tu2, err := uuid.NewV4()\n\tif err != nil {\n\t\tlog.Fatalf(\"failed to generate UUID: %v\", err)\n\t}\n\tlog.Printf(\"generated Version 4 UUID %v\", u2)\n\n\t// Parse a UUID from a string.\n\ts := \"6ba7b810-9dad-11d1-80b4-00c04fd430c8\"\n\tu3, err := uuid.FromString(s)\n\tif err != nil {\n\t\tlog.Fatalf(\"failed to parse UUID %q: %v\", s, err)\n\t}\n\tlog.Printf(\"successfully parsed UUID %v\", u3)\n}\n```\n\n## References\n\n* [RFC-4122](https://tools.ietf.org/html/rfc4122)\n* [DCE 1.1: Authentication and Security Services](http://pubs.opengroup.org/onlinepubs/9696989899/chap5.htm#tagcjh_08_02_01_01)\n* [New UUID Formats RFC Draft (Peabody) Rev 04](https://www.ietf.org/archive/id/draft-peabody-dispatch-new-uuid-format-04.html#)\n"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/codec.go",
"content": "// Copyright (C) 2013-2018 by Maxim Bublis \n//\n// Permission is hereby granted, free of charge, to any person obtaining\n// a copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to\n// the following conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\npackage uuid\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\n// FromBytes returns a UUID generated from the raw byte slice input.\n// It will return an error if the slice isn't 16 bytes long.\nfunc FromBytes(input []byte) (UUID, error) {\n\tu := UUID{}\n\terr := u.UnmarshalBinary(input)\n\treturn u, err\n}\n\n// FromBytesOrNil returns a UUID generated from the raw byte slice input.\n// Same behavior as FromBytes(), but returns uuid.Nil instead of an error.\nfunc FromBytesOrNil(input []byte) UUID {\n\tuuid, err := FromBytes(input)\n\tif err != nil {\n\t\treturn Nil\n\t}\n\treturn uuid\n}\n\nvar errInvalidFormat = errors.New(\"uuid: invalid UUID format\")\n\nfunc fromHexChar(c byte) byte {\n\tswitch {\n\tcase '0' <= c && c <= '9':\n\t\treturn c - '0'\n\tcase 'a' <= c && c <= 'f':\n\t\treturn c - 'a' + 10\n\tcase 'A' <= c && c <= 'F':\n\t\treturn c - 'A' + 10\n\t}\n\treturn 255\n}\n\n// Parse parses the UUID stored in the string text. Parsing and supported\n// formats are the same as UnmarshalText.\nfunc (u *UUID) Parse(s string) error {\n\tswitch len(s) {\n\tcase 32: // hash\n\tcase 36: // canonical\n\tcase 34, 38:\n\t\tif s[0] != '{' || s[len(s)-1] != '}' {\n\t\t\treturn fmt.Errorf(\"uuid: incorrect UUID format in string %q\", s)\n\t\t}\n\t\ts = s[1 : len(s)-1]\n\tcase 41, 45:\n\t\tif s[:9] != \"urn:uuid:\" {\n\t\t\treturn fmt.Errorf(\"uuid: incorrect UUID format in string %q\", s[:9])\n\t\t}\n\t\ts = s[9:]\n\tdefault:\n\t\treturn fmt.Errorf(\"uuid: incorrect UUID length %d in string %q\", len(s), s)\n\t}\n\t// canonical\n\tif len(s) == 36 {\n\t\tif s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {\n\t\t\treturn fmt.Errorf(\"uuid: incorrect UUID format in string %q\", s)\n\t\t}\n\t\tfor i, x := range [16]byte{\n\t\t\t0, 2, 4, 6,\n\t\t\t9, 11,\n\t\t\t14, 16,\n\t\t\t19, 21,\n\t\t\t24, 26, 28, 30, 32, 34,\n\t\t} {\n\t\t\tv1 := fromHexChar(s[x])\n\t\t\tv2 := fromHexChar(s[x+1])\n\t\t\tif v1|v2 == 255 {\n\t\t\t\treturn errInvalidFormat\n\t\t\t}\n\t\t\tu[i] = (v1 << 4) | v2\n\t\t}\n\t\treturn nil\n\t}\n\t// hash like\n\tfor i := 0; i < 32; i += 2 {\n\t\tv1 := fromHexChar(s[i])\n\t\tv2 := fromHexChar(s[i+1])\n\t\tif v1|v2 == 255 {\n\t\t\treturn errInvalidFormat\n\t\t}\n\t\tu[i/2] = (v1 << 4) | v2\n\t}\n\treturn nil\n}\n\n// FromString returns a UUID parsed from the input string.\n// Input is expected in a form accepted by UnmarshalText.\nfunc FromString(text string) (UUID, error) {\n\tvar u UUID\n\terr := u.Parse(text)\n\treturn u, err\n}\n\n// FromStringOrNil returns a UUID parsed from the input string.\n// Same behavior as FromString(), but returns uuid.Nil instead of an error.\nfunc FromStringOrNil(input string) UUID {\n\tuuid, err := FromString(input)\n\tif err != nil {\n\t\treturn Nil\n\t}\n\treturn uuid\n}\n\n// MarshalText implements the encoding.TextMarshaler interface.\n// The encoding is the same as returned by the String() method.\nfunc (u UUID) MarshalText() ([]byte, error) {\n\tvar buf [36]byte\n\tencodeCanonical(buf[:], u)\n\treturn buf[:], nil\n}\n\n// UnmarshalText implements the encoding.TextUnmarshaler interface.\n// Following formats are supported:\n//\n//\t\"6ba7b810-9dad-11d1-80b4-00c04fd430c8\",\n//\t\"{6ba7b810-9dad-11d1-80b4-00c04fd430c8}\",\n//\t\"urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8\"\n//\t\"6ba7b8109dad11d180b400c04fd430c8\"\n//\t\"{6ba7b8109dad11d180b400c04fd430c8}\",\n//\t\"urn:uuid:6ba7b8109dad11d180b400c04fd430c8\"\n//\n// ABNF for supported UUID text representation follows:\n//\n//\tURN := 'urn'\n//\tUUID-NID := 'uuid'\n//\n//\thexdig := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |\n//\t 'a' | 'b' | 'c' | 'd' | 'e' | 'f' |\n//\t 'A' | 'B' | 'C' | 'D' | 'E' | 'F'\n//\n//\thexoct := hexdig hexdig\n//\t2hexoct := hexoct hexoct\n//\t4hexoct := 2hexoct 2hexoct\n//\t6hexoct := 4hexoct 2hexoct\n//\t12hexoct := 6hexoct 6hexoct\n//\n//\thashlike := 12hexoct\n//\tcanonical := 4hexoct '-' 2hexoct '-' 2hexoct '-' 6hexoct\n//\n//\tplain := canonical | hashlike\n//\tuuid := canonical | hashlike | braced | urn\n//\n//\tbraced := '{' plain '}' | '{' hashlike '}'\n//\turn := URN ':' UUID-NID ':' plain\nfunc (u *UUID) UnmarshalText(b []byte) error {\n\tswitch len(b) {\n\tcase 32: // hash\n\tcase 36: // canonical\n\tcase 34, 38:\n\t\tif b[0] != '{' || b[len(b)-1] != '}' {\n\t\t\treturn fmt.Errorf(\"uuid: incorrect UUID format in string %q\", b)\n\t\t}\n\t\tb = b[1 : len(b)-1]\n\tcase 41, 45:\n\t\tif string(b[:9]) != \"urn:uuid:\" {\n\t\t\treturn fmt.Errorf(\"uuid: incorrect UUID format in string %q\", b[:9])\n\t\t}\n\t\tb = b[9:]\n\tdefault:\n\t\treturn fmt.Errorf(\"uuid: incorrect UUID length %d in string %q\", len(b), b)\n\t}\n\tif len(b) == 36 {\n\t\tif b[8] != '-' || b[13] != '-' || b[18] != '-' || b[23] != '-' {\n\t\t\treturn fmt.Errorf(\"uuid: incorrect UUID format in string %q\", b)\n\t\t}\n\t\tfor i, x := range [16]byte{\n\t\t\t0, 2, 4, 6,\n\t\t\t9, 11,\n\t\t\t14, 16,\n\t\t\t19, 21,\n\t\t\t24, 26, 28, 30, 32, 34,\n\t\t} {\n\t\t\tv1 := fromHexChar(b[x])\n\t\t\tv2 := fromHexChar(b[x+1])\n\t\t\tif v1|v2 == 255 {\n\t\t\t\treturn errInvalidFormat\n\t\t\t}\n\t\t\tu[i] = (v1 << 4) | v2\n\t\t}\n\t\treturn nil\n\t}\n\tfor i := 0; i < 32; i += 2 {\n\t\tv1 := fromHexChar(b[i])\n\t\tv2 := fromHexChar(b[i+1])\n\t\tif v1|v2 == 255 {\n\t\t\treturn errInvalidFormat\n\t\t}\n\t\tu[i/2] = (v1 << 4) | v2\n\t}\n\treturn nil\n}\n\n// MarshalBinary implements the encoding.BinaryMarshaler interface.\nfunc (u UUID) MarshalBinary() ([]byte, error) {\n\treturn u.Bytes(), nil\n}\n\n// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.\n// It will return an error if the slice isn't 16 bytes long.\nfunc (u *UUID) UnmarshalBinary(data []byte) error {\n\tif len(data) != Size {\n\t\treturn fmt.Errorf(\"uuid: UUID must be exactly 16 bytes long, got %d bytes\", len(data))\n\t}\n\tcopy(u[:], data)\n\n\treturn nil\n}\n"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/fuzz.go",
"content": "// Copyright (c) 2018 Andrei Tudor Călin \n//\n// Permission is hereby granted, free of charge, to any person obtaining\n// a copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to\n// the following conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n//go:build gofuzz\n// +build gofuzz\n\npackage uuid\n\n// Fuzz implements a simple fuzz test for FromString / UnmarshalText.\n//\n// To run:\n//\n//\t$ go get github.com/dvyukov/go-fuzz/...\n//\t$ cd $GOPATH/src/github.com/gofrs/uuid\n//\t$ go-fuzz-build github.com/gofrs/uuid\n//\t$ go-fuzz -bin=uuid-fuzz.zip -workdir=./testdata\n//\n// If you make significant changes to FromString / UnmarshalText and add\n// new cases to fromStringTests (in codec_test.go), please run\n//\n//\t$ go test -seed_fuzz_corpus\n//\n// to seed the corpus with the new interesting inputs, then run the fuzzer.\nfunc Fuzz(data []byte) int {\n\t_, err := FromString(string(data))\n\tif err != nil {\n\t\treturn 0\n\t}\n\treturn 1\n}\n"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/generator.go",
"content": "// Copyright (C) 2013-2018 by Maxim Bublis \n//\n// Permission is hereby granted, free of charge, to any person obtaining\n// a copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to\n// the following conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\npackage uuid\n\nimport (\n\t\"crypto/md5\"\n\t\"crypto/rand\"\n\t\"crypto/sha1\"\n\t\"encoding/binary\"\n\t\"fmt\"\n\t\"hash\"\n\t\"io\"\n\t\"net\"\n\t\"sync\"\n\t\"time\"\n)\n\n// Difference in 100-nanosecond intervals between\n// UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970).\nconst epochStart = 122192928000000000\n\n// EpochFunc is the function type used to provide the current time.\ntype EpochFunc func() time.Time\n\n// HWAddrFunc is the function type used to provide hardware (MAC) addresses.\ntype HWAddrFunc func() (net.HardwareAddr, error)\n\n// DefaultGenerator is the default UUID Generator used by this package.\nvar DefaultGenerator Generator = NewGen()\n\n// NewV1 returns a UUID based on the current timestamp and MAC address.\nfunc NewV1() (UUID, error) {\n\treturn DefaultGenerator.NewV1()\n}\n\n// NewV3 returns a UUID based on the MD5 hash of the namespace UUID and name.\nfunc NewV3(ns UUID, name string) UUID {\n\treturn DefaultGenerator.NewV3(ns, name)\n}\n\n// NewV4 returns a randomly generated UUID.\nfunc NewV4() (UUID, error) {\n\treturn DefaultGenerator.NewV4()\n}\n\n// NewV5 returns a UUID based on SHA-1 hash of the namespace UUID and name.\nfunc NewV5(ns UUID, name string) UUID {\n\treturn DefaultGenerator.NewV5(ns, name)\n}\n\n// NewV6 returns a k-sortable UUID based on a timestamp and 48 bits of\n// pseudorandom data. The timestamp in a V6 UUID is the same as V1, with the bit\n// order being adjusted to allow the UUID to be k-sortable.\n//\n// This is implemented based on revision 03 of the Peabody UUID draft, and may\n// be subject to change pending further revisions. Until the final specification\n// revision is finished, changes required to implement updates to the spec will\n// not be considered a breaking change. They will happen as a minor version\n// releases until the spec is final.\nfunc NewV6() (UUID, error) {\n\treturn DefaultGenerator.NewV6()\n}\n\n// NewV7 returns a k-sortable UUID based on the current millisecond precision\n// UNIX epoch and 74 bits of pseudorandom data. It supports single-node batch generation (multiple UUIDs in the same timestamp) with a Monotonic Random counter.\n//\n// This is implemented based on revision 04 of the Peabody UUID draft, and may\n// be subject to change pending further revisions. Until the final specification\n// revision is finished, changes required to implement updates to the spec will\n// not be considered a breaking change. They will happen as a minor version\n// releases until the spec is final.\nfunc NewV7() (UUID, error) {\n\treturn DefaultGenerator.NewV7()\n}\n\n// Generator provides an interface for generating UUIDs.\ntype Generator interface {\n\tNewV1() (UUID, error)\n\tNewV3(ns UUID, name string) UUID\n\tNewV4() (UUID, error)\n\tNewV5(ns UUID, name string) UUID\n\tNewV6() (UUID, error)\n\tNewV7() (UUID, error)\n}\n\n// Gen is a reference UUID generator based on the specifications laid out in\n// RFC-4122 and DCE 1.1: Authentication and Security Services. This type\n// satisfies the Generator interface as defined in this package.\n//\n// For consumers who are generating V1 UUIDs, but don't want to expose the MAC\n// address of the node generating the UUIDs, the NewGenWithHWAF() function has been\n// provided as a convenience. See the function's documentation for more info.\n//\n// The authors of this package do not feel that the majority of users will need\n// to obfuscate their MAC address, and so we recommend using NewGen() to create\n// a new generator.\ntype Gen struct {\n\tclockSequenceOnce sync.Once\n\thardwareAddrOnce sync.Once\n\tstorageMutex sync.Mutex\n\n\trand io.Reader\n\n\tepochFunc EpochFunc\n\thwAddrFunc HWAddrFunc\n\tlastTime uint64\n\tclockSequence uint16\n\thardwareAddr [6]byte\n}\n\n// GenOption is a function type that can be used to configure a Gen generator.\ntype GenOption func(*Gen)\n\n// interface check -- build will fail if *Gen doesn't satisfy Generator\nvar _ Generator = (*Gen)(nil)\n\n// NewGen returns a new instance of Gen with some default values set. Most\n// people should use this.\nfunc NewGen() *Gen {\n\treturn NewGenWithHWAF(defaultHWAddrFunc)\n}\n\n// NewGenWithHWAF builds a new UUID generator with the HWAddrFunc provided. Most\n// consumers should use NewGen() instead.\n//\n// This is used so that consumers can generate their own MAC addresses, for use\n// in the generated UUIDs, if there is some concern about exposing the physical\n// address of the machine generating the UUID.\n//\n// The Gen generator will only invoke the HWAddrFunc once, and cache that MAC\n// address for all the future UUIDs generated by it. If you'd like to switch the\n// MAC address being used, you'll need to create a new generator using this\n// function.\nfunc NewGenWithHWAF(hwaf HWAddrFunc) *Gen {\n\treturn NewGenWithOptions(WithHWAddrFunc(hwaf))\n}\n\n// NewGenWithOptions returns a new instance of Gen with the options provided.\n// Most people should use NewGen() or NewGenWithHWAF() instead.\n//\n// To customize the generator, you can pass in one or more GenOption functions.\n// For example:\n//\n//\tgen := NewGenWithOptions(\n//\t WithHWAddrFunc(myHWAddrFunc),\n//\t WithEpochFunc(myEpochFunc),\n//\t WithRandomReader(myRandomReader),\n//\t)\n//\n// NewGenWithOptions(WithHWAddrFunc(myHWAddrFunc)) is equivalent to calling\n// NewGenWithHWAF(myHWAddrFunc)\n// NewGenWithOptions() is equivalent to calling NewGen()\nfunc NewGenWithOptions(opts ...GenOption) *Gen {\n\tgen := &Gen{\n\t\tepochFunc: time.Now,\n\t\thwAddrFunc: defaultHWAddrFunc,\n\t\trand: rand.Reader,\n\t}\n\n\tfor _, opt := range opts {\n\t\topt(gen)\n\t}\n\n\treturn gen\n}\n\n// WithHWAddrFunc is a GenOption that allows you to provide your own HWAddrFunc\n// function.\n// When this option is nil, the defaultHWAddrFunc is used.\nfunc WithHWAddrFunc(hwaf HWAddrFunc) GenOption {\n\treturn func(gen *Gen) {\n\t\tif hwaf == nil {\n\t\t\thwaf = defaultHWAddrFunc\n\t\t}\n\n\t\tgen.hwAddrFunc = hwaf\n\t}\n}\n\n// WithEpochFunc is a GenOption that allows you to provide your own EpochFunc\n// function.\n// When this option is nil, time.Now is used.\nfunc WithEpochFunc(epochf EpochFunc) GenOption {\n\treturn func(gen *Gen) {\n\t\tif epochf == nil {\n\t\t\tepochf = time.Now\n\t\t}\n\n\t\tgen.epochFunc = epochf\n\t}\n}\n\n// WithRandomReader is a GenOption that allows you to provide your own random\n// reader.\n// When this option is nil, the default rand.Reader is used.\nfunc WithRandomReader(reader io.Reader) GenOption {\n\treturn func(gen *Gen) {\n\t\tif reader == nil {\n\t\t\treader = rand.Reader\n\t\t}\n\n\t\tgen.rand = reader\n\t}\n}\n\n// NewV1 returns a UUID based on the current timestamp and MAC address.\nfunc (g *Gen) NewV1() (UUID, error) {\n\tu := UUID{}\n\n\ttimeNow, clockSeq, err := g.getClockSequence(false)\n\tif err != nil {\n\t\treturn Nil, err\n\t}\n\tbinary.BigEndian.PutUint32(u[0:], uint32(timeNow))\n\tbinary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32))\n\tbinary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48))\n\tbinary.BigEndian.PutUint16(u[8:], clockSeq)\n\n\thardwareAddr, err := g.getHardwareAddr()\n\tif err != nil {\n\t\treturn Nil, err\n\t}\n\tcopy(u[10:], hardwareAddr)\n\n\tu.SetVersion(V1)\n\tu.SetVariant(VariantRFC4122)\n\n\treturn u, nil\n}\n\n// NewV3 returns a UUID based on the MD5 hash of the namespace UUID and name.\nfunc (g *Gen) NewV3(ns UUID, name string) UUID {\n\tu := newFromHash(md5.New(), ns, name)\n\tu.SetVersion(V3)\n\tu.SetVariant(VariantRFC4122)\n\n\treturn u\n}\n\n// NewV4 returns a randomly generated UUID.\nfunc (g *Gen) NewV4() (UUID, error) {\n\tu := UUID{}\n\tif _, err := io.ReadFull(g.rand, u[:]); err != nil {\n\t\treturn Nil, err\n\t}\n\tu.SetVersion(V4)\n\tu.SetVariant(VariantRFC4122)\n\n\treturn u, nil\n}\n\n// NewV5 returns a UUID based on SHA-1 hash of the namespace UUID and name.\nfunc (g *Gen) NewV5(ns UUID, name string) UUID {\n\tu := newFromHash(sha1.New(), ns, name)\n\tu.SetVersion(V5)\n\tu.SetVariant(VariantRFC4122)\n\n\treturn u\n}\n\n// NewV6 returns a k-sortable UUID based on a timestamp and 48 bits of\n// pseudorandom data. The timestamp in a V6 UUID is the same as V1, with the bit\n// order being adjusted to allow the UUID to be k-sortable.\n//\n// This is implemented based on revision 03 of the Peabody UUID draft, and may\n// be subject to change pending further revisions. Until the final specification\n// revision is finished, changes required to implement updates to the spec will\n// not be considered a breaking change. They will happen as a minor version\n// releases until the spec is final.\nfunc (g *Gen) NewV6() (UUID, error) {\n\tvar u UUID\n\n\tif _, err := io.ReadFull(g.rand, u[10:]); err != nil {\n\t\treturn Nil, err\n\t}\n\n\ttimeNow, clockSeq, err := g.getClockSequence(false)\n\tif err != nil {\n\t\treturn Nil, err\n\t}\n\n\tbinary.BigEndian.PutUint32(u[0:], uint32(timeNow>>28)) // set time_high\n\tbinary.BigEndian.PutUint16(u[4:], uint16(timeNow>>12)) // set time_mid\n\tbinary.BigEndian.PutUint16(u[6:], uint16(timeNow&0xfff)) // set time_low (minus four version bits)\n\tbinary.BigEndian.PutUint16(u[8:], clockSeq&0x3fff) // set clk_seq_hi_res (minus two variant bits)\n\n\tu.SetVersion(V6)\n\tu.SetVariant(VariantRFC4122)\n\n\treturn u, nil\n}\n\n// getClockSequence returns the epoch and clock sequence for V1,V6 and V7 UUIDs.\n//\n//\tWhen useUnixTSMs is false, it uses the Coordinated Universal Time (UTC) as a count of 100-\n//\n// nanosecond intervals since 00:00:00.00, 15 October 1582 (the date of Gregorian reform to the Christian calendar).\nfunc (g *Gen) getClockSequence(useUnixTSMs bool) (uint64, uint16, error) {\n\tvar err error\n\tg.clockSequenceOnce.Do(func() {\n\t\tbuf := make([]byte, 2)\n\t\tif _, err = io.ReadFull(g.rand, buf); err != nil {\n\t\t\treturn\n\t\t}\n\t\tg.clockSequence = binary.BigEndian.Uint16(buf)\n\t})\n\tif err != nil {\n\t\treturn 0, 0, err\n\t}\n\n\tg.storageMutex.Lock()\n\tdefer g.storageMutex.Unlock()\n\n\tvar timeNow uint64\n\tif useUnixTSMs {\n\t\ttimeNow = uint64(g.epochFunc().UnixMilli())\n\t} else {\n\t\ttimeNow = g.getEpoch()\n\t}\n\t// Clock didn't change since last UUID generation.\n\t// Should increase clock sequence.\n\tif timeNow <= g.lastTime {\n\t\tg.clockSequence++\n\t}\n\tg.lastTime = timeNow\n\n\treturn timeNow, g.clockSequence, nil\n}\n\n// NewV7 returns a k-sortable UUID based on the current millisecond precision\n// UNIX epoch and 74 bits of pseudorandom data.\n//\n// This is implemented based on revision 04 of the Peabody UUID draft, and may\n// be subject to change pending further revisions. Until the final specification\n// revision is finished, changes required to implement updates to the spec will\n// not be considered a breaking change. They will happen as a minor version\n// releases until the spec is final.\nfunc (g *Gen) NewV7() (UUID, error) {\n\tvar u UUID\n\t/* https://www.ietf.org/archive/id/draft-peabody-dispatch-new-uuid-format-04.html#name-uuid-version-7\n\t\t0 1 2 3\n\t 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n\t +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\t | unix_ts_ms |\n\t +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\t | unix_ts_ms | ver | rand_a |\n\t +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\t |var| rand_b |\n\t +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\t | rand_b |\n\t +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ */\n\n\tms, clockSeq, err := g.getClockSequence(true)\n\tif err != nil {\n\t\treturn Nil, err\n\t}\n\t//UUIDv7 features a 48 bit timestamp. First 32bit (4bytes) represents seconds since 1970, followed by 2 bytes for the ms granularity.\n\tu[0] = byte(ms >> 40) //1-6 bytes: big-endian unsigned number of Unix epoch timestamp\n\tu[1] = byte(ms >> 32)\n\tu[2] = byte(ms >> 24)\n\tu[3] = byte(ms >> 16)\n\tu[4] = byte(ms >> 8)\n\tu[5] = byte(ms)\n\n\t//support batching by using a monotonic pseudo-random sequence\n\t//The 6th byte contains the version and partially rand_a data.\n\t//We will lose the most significant bites from the clockSeq (with SetVersion), but it is ok, we need the least significant that contains the counter to ensure the monotonic property\n\tbinary.BigEndian.PutUint16(u[6:8], clockSeq) // set rand_a with clock seq which is random and monotonic\n\n\t//override first 4bits of u[6].\n\tu.SetVersion(V7)\n\n\t//set rand_b 64bits of pseudo-random bits (first 2 will be overridden)\n\tif _, err = io.ReadFull(g.rand, u[8:16]); err != nil {\n\t\treturn Nil, err\n\t}\n\t//override first 2 bits of byte[8] for the variant\n\tu.SetVariant(VariantRFC4122)\n\n\treturn u, nil\n}\n\n// Returns the hardware address.\nfunc (g *Gen) getHardwareAddr() ([]byte, error) {\n\tvar err error\n\tg.hardwareAddrOnce.Do(func() {\n\t\tvar hwAddr net.HardwareAddr\n\t\tif hwAddr, err = g.hwAddrFunc(); err == nil {\n\t\t\tcopy(g.hardwareAddr[:], hwAddr)\n\t\t\treturn\n\t\t}\n\n\t\t// Initialize hardwareAddr randomly in case\n\t\t// of real network interfaces absence.\n\t\tif _, err = io.ReadFull(g.rand, g.hardwareAddr[:]); err != nil {\n\t\t\treturn\n\t\t}\n\t\t// Set multicast bit as recommended by RFC-4122\n\t\tg.hardwareAddr[0] |= 0x01\n\t})\n\tif err != nil {\n\t\treturn []byte{}, err\n\t}\n\treturn g.hardwareAddr[:], nil\n}\n\n// Returns the difference between UUID epoch (October 15, 1582)\n// and current time in 100-nanosecond intervals.\nfunc (g *Gen) getEpoch() uint64 {\n\treturn epochStart + uint64(g.epochFunc().UnixNano()/100)\n}\n\n// Returns the UUID based on the hashing of the namespace UUID and name.\nfunc newFromHash(h hash.Hash, ns UUID, name string) UUID {\n\tu := UUID{}\n\th.Write(ns[:])\n\th.Write([]byte(name))\n\tcopy(u[:], h.Sum(nil))\n\n\treturn u\n}\n\nvar netInterfaces = net.Interfaces\n\n// Returns the hardware address.\nfunc defaultHWAddrFunc() (net.HardwareAddr, error) {\n\tifaces, err := netInterfaces()\n\tif err != nil {\n\t\treturn []byte{}, err\n\t}\n\tfor _, iface := range ifaces {\n\t\tif len(iface.HardwareAddr) >= 6 {\n\t\t\treturn iface.HardwareAddr, nil\n\t\t}\n\t}\n\treturn []byte{}, fmt.Errorf(\"uuid: no HW address found\")\n}\n"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/sql.go",
"content": "// Copyright (C) 2013-2018 by Maxim Bublis \n//\n// Permission is hereby granted, free of charge, to any person obtaining\n// a copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to\n// the following conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\npackage uuid\n\nimport (\n\t\"database/sql\"\n\t\"database/sql/driver\"\n\t\"fmt\"\n)\n\nvar _ driver.Valuer = UUID{}\nvar _ sql.Scanner = (*UUID)(nil)\n\n// Value implements the driver.Valuer interface.\nfunc (u UUID) Value() (driver.Value, error) {\n\treturn u.String(), nil\n}\n\n// Scan implements the sql.Scanner interface.\n// A 16-byte slice will be handled by UnmarshalBinary, while\n// a longer byte slice or a string will be handled by UnmarshalText.\nfunc (u *UUID) Scan(src interface{}) error {\n\tswitch src := src.(type) {\n\tcase UUID: // support gorm convert from UUID to NullUUID\n\t\t*u = src\n\t\treturn nil\n\n\tcase []byte:\n\t\tif len(src) == Size {\n\t\t\treturn u.UnmarshalBinary(src)\n\t\t}\n\t\treturn u.UnmarshalText(src)\n\n\tcase string:\n\t\tuu, err := FromString(src)\n\t\t*u = uu\n\t\treturn err\n\t}\n\n\treturn fmt.Errorf(\"uuid: cannot convert %T to UUID\", src)\n}\n\n// NullUUID can be used with the standard sql package to represent a\n// UUID value that can be NULL in the database.\ntype NullUUID struct {\n\tUUID UUID\n\tValid bool\n}\n\n// Value implements the driver.Valuer interface.\nfunc (u NullUUID) Value() (driver.Value, error) {\n\tif !u.Valid {\n\t\treturn nil, nil\n\t}\n\t// Delegate to UUID Value function\n\treturn u.UUID.Value()\n}\n\n// Scan implements the sql.Scanner interface.\nfunc (u *NullUUID) Scan(src interface{}) error {\n\tif src == nil {\n\t\tu.UUID, u.Valid = Nil, false\n\t\treturn nil\n\t}\n\n\t// Delegate to UUID Scan function\n\tu.Valid = true\n\treturn u.UUID.Scan(src)\n}\n\nvar nullJSON = []byte(\"null\")\n\n// MarshalJSON marshals the NullUUID as null or the nested UUID\nfunc (u NullUUID) MarshalJSON() ([]byte, error) {\n\tif !u.Valid {\n\t\treturn nullJSON, nil\n\t}\n\tvar buf [38]byte\n\tbuf[0] = '\"'\n\tencodeCanonical(buf[1:37], u.UUID)\n\tbuf[37] = '\"'\n\treturn buf[:], nil\n}\n\n// UnmarshalJSON unmarshals a NullUUID\nfunc (u *NullUUID) UnmarshalJSON(b []byte) error {\n\tif string(b) == \"null\" {\n\t\tu.UUID, u.Valid = Nil, false\n\t\treturn nil\n\t}\n\tif n := len(b); n >= 2 && b[0] == '\"' {\n\t\tb = b[1 : n-1]\n\t}\n\terr := u.UUID.UnmarshalText(b)\n\tu.Valid = (err == nil)\n\treturn err\n}\n"
},
{
"path": "vendor/github.com/gofrs/uuid/v5/uuid.go",
"content": "// Copyright (C) 2013-2018 by Maxim Bublis \n//\n// Permission is hereby granted, free of charge, to any person obtaining\n// a copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to\n// the following conditions:\n//\n// The above copyright notice and this permission notice shall be\n// included in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// Package uuid provides implementations of the Universally Unique Identifier\n// (UUID), as specified in RFC-4122 and the Peabody RFC Draft (revision 03).\n//\n// RFC-4122[1] provides the specification for versions 1, 3, 4, and 5. The\n// Peabody UUID RFC Draft[2] provides the specification for the new k-sortable\n// UUIDs, versions 6 and 7.\n//\n// DCE 1.1[3] provides the specification for version 2, but version 2 support\n// was removed from this package in v4 due to some concerns with the\n// specification itself. Reading the spec, it seems that it would result in\n// generating UUIDs that aren't very unique. In having read the spec it seemed\n// that our implementation did not meet the spec. It also seems to be at-odds\n// with RFC 4122, meaning we would need quite a bit of special code to support\n// it. Lastly, there were no Version 2 implementations that we could find to\n// ensure we were understanding the specification correctly.\n//\n// [1] https://tools.ietf.org/html/rfc4122\n// [2] https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-03\n// [3] http://pubs.opengroup.org/onlinepubs/9696989899/chap5.htm#tagcjh_08_02_01_01\npackage uuid\n\nimport (\n\t\"encoding/binary\"\n\t\"encoding/hex\"\n\t\"fmt\"\n\t\"time\"\n)\n\n// Size of a UUID in bytes.\nconst Size = 16\n\n// UUID is an array type to represent the value of a UUID, as defined in RFC-4122.\ntype UUID [Size]byte\n\n// UUID versions.\nconst (\n\t_ byte = iota\n\tV1 // Version 1 (date-time and MAC address)\n\t_ // Version 2 (date-time and MAC address, DCE security version) [removed]\n\tV3 // Version 3 (namespace name-based)\n\tV4 // Version 4 (random)\n\tV5 // Version 5 (namespace name-based)\n\tV6 // Version 6 (k-sortable timestamp and random data, field-compatible with v1) [peabody draft]\n\tV7 // Version 7 (k-sortable timestamp and random data) [peabody draft]\n\t_ // Version 8 (k-sortable timestamp, meant for custom implementations) [peabody draft] [not implemented]\n)\n\n// UUID layout variants.\nconst (\n\tVariantNCS byte = iota\n\tVariantRFC4122\n\tVariantMicrosoft\n\tVariantFuture\n)\n\n// UUID DCE domains.\nconst (\n\tDomainPerson = iota\n\tDomainGroup\n\tDomainOrg\n)\n\n// Timestamp is the count of 100-nanosecond intervals since 00:00:00.00,\n// 15 October 1582 within a V1 UUID. This type has no meaning for other\n// UUID versions since they don't have an embedded timestamp.\ntype Timestamp uint64\n\nconst _100nsPerSecond = 10000000\n\n// Time returns the UTC time.Time representation of a Timestamp\nfunc (t Timestamp) Time() (time.Time, error) {\n\tsecs := uint64(t) / _100nsPerSecond\n\tnsecs := 100 * (uint64(t) % _100nsPerSecond)\n\n\treturn time.Unix(int64(secs)-(epochStart/_100nsPerSecond), int64(nsecs)), nil\n}\n\n// TimestampFromV1 returns the Timestamp embedded within a V1 UUID.\n// Returns an error if the UUID is any version other than 1.\nfunc TimestampFromV1(u UUID) (Timestamp, error) {\n\tif u.Version() != 1 {\n\t\terr := fmt.Errorf(\"uuid: %s is version %d, not version 1\", u, u.Version())\n\t\treturn 0, err\n\t}\n\n\tlow := binary.BigEndian.Uint32(u[0:4])\n\tmid := binary.BigEndian.Uint16(u[4:6])\n\thi := binary.BigEndian.Uint16(u[6:8]) & 0xfff\n\n\treturn Timestamp(uint64(low) + (uint64(mid) << 32) + (uint64(hi) << 48)), nil\n}\n\n// TimestampFromV6 returns the Timestamp embedded within a V6 UUID. This\n// function returns an error if the UUID is any version other than 6.\n//\n// This is implemented based on revision 03 of the Peabody UUID draft, and may\n// be subject to change pending further revisions. Until the final specification\n// revision is finished, changes required to implement updates to the spec will\n// not be considered a breaking change. They will happen as a minor version\n// releases until the spec is final.\nfunc TimestampFromV6(u UUID) (Timestamp, error) {\n\tif u.Version() != 6 {\n\t\treturn 0, fmt.Errorf(\"uuid: %s is version %d, not version 6\", u, u.Version())\n\t}\n\n\thi := binary.BigEndian.Uint32(u[0:4])\n\tmid := binary.BigEndian.Uint16(u[4:6])\n\tlow := binary.BigEndian.Uint16(u[6:8]) & 0xfff\n\n\treturn Timestamp(uint64(low) + (uint64(mid) << 12) + (uint64(hi) << 28)), nil\n}\n\n// Nil is the nil UUID, as specified in RFC-4122, that has all 128 bits set to\n// zero.\nvar Nil = UUID{}\n\n// Predefined namespace UUIDs.\nvar (\n\tNamespaceDNS = Must(FromString(\"6ba7b810-9dad-11d1-80b4-00c04fd430c8\"))\n\tNamespaceURL = Must(FromString(\"6ba7b811-9dad-11d1-80b4-00c04fd430c8\"))\n\tNamespaceOID = Must(FromString(\"6ba7b812-9dad-11d1-80b4-00c04fd430c8\"))\n\tNamespaceX500 = Must(FromString(\"6ba7b814-9dad-11d1-80b4-00c04fd430c8\"))\n)\n\n// IsNil returns if the UUID is equal to the nil UUID\nfunc (u UUID) IsNil() bool {\n\treturn u == Nil\n}\n\n// Version returns the algorithm version used to generate the UUID.\nfunc (u UUID) Version() byte {\n\treturn u[6] >> 4\n}\n\n// Variant returns the UUID layout variant.\nfunc (u UUID) Variant() byte {\n\tswitch {\n\tcase (u[8] >> 7) == 0x00:\n\t\treturn VariantNCS\n\tcase (u[8] >> 6) == 0x02:\n\t\treturn VariantRFC4122\n\tcase (u[8] >> 5) == 0x06:\n\t\treturn VariantMicrosoft\n\tcase (u[8] >> 5) == 0x07:\n\t\tfallthrough\n\tdefault:\n\t\treturn VariantFuture\n\t}\n}\n\n// Bytes returns a byte slice representation of the UUID.\nfunc (u UUID) Bytes() []byte {\n\treturn u[:]\n}\n\n// encodeCanonical encodes the canonical RFC-4122 form of UUID u into the\n// first 36 bytes dst.\nfunc encodeCanonical(dst []byte, u UUID) {\n\tconst hextable = \"0123456789abcdef\"\n\tdst[8] = '-'\n\tdst[13] = '-'\n\tdst[18] = '-'\n\tdst[23] = '-'\n\tfor i, x := range [16]byte{\n\t\t0, 2, 4, 6,\n\t\t9, 11,\n\t\t14, 16,\n\t\t19, 21,\n\t\t24, 26, 28, 30, 32, 34,\n\t} {\n\t\tc := u[i]\n\t\tdst[x] = hextable[c>>4]\n\t\tdst[x+1] = hextable[c&0x0f]\n\t}\n}\n\n// String returns a canonical RFC-4122 string representation of the UUID:\n// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.\nfunc (u UUID) String() string {\n\tvar buf [36]byte\n\tencodeCanonical(buf[:], u)\n\treturn string(buf[:])\n}\n\n// Format implements fmt.Formatter for UUID values.\n//\n// The behavior is as follows:\n// The 'x' and 'X' verbs output only the hex digits of the UUID, using a-f for 'x' and A-F for 'X'.\n// The 'v', '+v', 's' and 'q' verbs return the canonical RFC-4122 string representation.\n// The 'S' verb returns the RFC-4122 format, but with capital hex digits.\n// The '#v' verb returns the \"Go syntax\" representation, which is a 16 byte array initializer.\n// All other verbs not handled directly by the fmt package (like '%p') are unsupported and will return\n// \"%!verb(uuid.UUID=value)\" as recommended by the fmt package.\nfunc (u UUID) Format(f fmt.State, c rune) {\n\tif c == 'v' && f.Flag('#') {\n\t\tfmt.Fprintf(f, \"%#v\", [Size]byte(u))\n\t\treturn\n\t}\n\tswitch c {\n\tcase 'x', 'X':\n\t\tb := make([]byte, 32)\n\t\thex.Encode(b, u[:])\n\t\tif c == 'X' {\n\t\t\ttoUpperHex(b)\n\t\t}\n\t\t_, _ = f.Write(b)\n\tcase 'v', 's', 'S':\n\t\tb, _ := u.MarshalText()\n\t\tif c == 'S' {\n\t\t\ttoUpperHex(b)\n\t\t}\n\t\t_, _ = f.Write(b)\n\tcase 'q':\n\t\tb := make([]byte, 38)\n\t\tb[0] = '\"'\n\t\tencodeCanonical(b[1:], u)\n\t\tb[37] = '\"'\n\t\t_, _ = f.Write(b)\n\tdefault:\n\t\t// invalid/unsupported format verb\n\t\tfmt.Fprintf(f, \"%%!%c(uuid.UUID=%s)\", c, u.String())\n\t}\n}\n\nfunc toUpperHex(b []byte) {\n\tfor i, c := range b {\n\t\tif 'a' <= c && c <= 'f' {\n\t\t\tb[i] = c - ('a' - 'A')\n\t\t}\n\t}\n}\n\n// SetVersion sets the version bits.\nfunc (u *UUID) SetVersion(v byte) {\n\tu[6] = (u[6] & 0x0f) | (v << 4)\n}\n\n// SetVariant sets the variant bits.\nfunc (u *UUID) SetVariant(v byte) {\n\tswitch v {\n\tcase VariantNCS:\n\t\tu[8] = (u[8]&(0xff>>1) | (0x00 << 7))\n\tcase VariantRFC4122:\n\t\tu[8] = (u[8]&(0xff>>2) | (0x02 << 6))\n\tcase VariantMicrosoft:\n\t\tu[8] = (u[8]&(0xff>>3) | (0x06 << 5))\n\tcase VariantFuture:\n\t\tfallthrough\n\tdefault:\n\t\tu[8] = (u[8]&(0xff>>3) | (0x07 << 5))\n\t}\n}\n\n// Must is a helper that wraps a call to a function returning (UUID, error)\n// and panics if the error is non-nil. It is intended for use in variable\n// initializations such as\n//\n//\tvar packageUUID = uuid.Must(uuid.FromString(\"123e4567-e89b-12d3-a456-426655440000\"))\nfunc Must(u UUID, err error) UUID {\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\treturn u\n}\n"
},
{
"path": "vendor/github.com/gorilla/mux/.editorconfig",
"content": "; https://editorconfig.org/\n\nroot = true\n\n[*]\ninsert_final_newline = true\ncharset = utf-8\ntrim_trailing_whitespace = true\nindent_style = space\nindent_size = 2\n\n[{Makefile,go.mod,go.sum,*.go,.gitmodules}]\nindent_style = tab\nindent_size = 4\n\n[*.md]\nindent_size = 4\ntrim_trailing_whitespace = false\n\neclint_indent_style = unset"
},
{
"path": "vendor/github.com/gorilla/mux/.gitignore",
"content": "coverage.coverprofile\n"
},
{
"path": "vendor/github.com/gorilla/mux/LICENSE",
"content": "Copyright (c) 2023 The Gorilla Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n\t * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n\t * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n\t * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
},
{
"path": "vendor/github.com/gorilla/mux/Makefile",
"content": "GO_LINT=$(shell which golangci-lint 2> /dev/null || echo '')\nGO_LINT_URI=github.com/golangci/golangci-lint/cmd/golangci-lint@latest\n\nGO_SEC=$(shell which gosec 2> /dev/null || echo '')\nGO_SEC_URI=github.com/securego/gosec/v2/cmd/gosec@latest\n\nGO_VULNCHECK=$(shell which govulncheck 2> /dev/null || echo '')\nGO_VULNCHECK_URI=golang.org/x/vuln/cmd/govulncheck@latest\n\n.PHONY: golangci-lint\ngolangci-lint:\n\t$(if $(GO_LINT), ,go install $(GO_LINT_URI))\n\t@echo \"##### Running golangci-lint\"\n\tgolangci-lint run -v\n\t\n.PHONY: gosec\ngosec:\n\t$(if $(GO_SEC), ,go install $(GO_SEC_URI))\n\t@echo \"##### Running gosec\"\n\tgosec ./...\n\n.PHONY: govulncheck\ngovulncheck:\n\t$(if $(GO_VULNCHECK), ,go install $(GO_VULNCHECK_URI))\n\t@echo \"##### Running govulncheck\"\n\tgovulncheck ./...\n\n.PHONY: verify\nverify: golangci-lint gosec govulncheck\n\n.PHONY: test\ntest:\n\t@echo \"##### Running tests\"\n\tgo test -race -cover -coverprofile=coverage.coverprofile -covermode=atomic -v ./..."
},
{
"path": "vendor/github.com/gorilla/mux/README.md",
"content": "# gorilla/mux\n\n\n[](https://codecov.io/github/gorilla/mux)\n[](https://godoc.org/github.com/gorilla/mux)\n[](https://sourcegraph.com/github.com/gorilla/mux?badge)\n\n\n\n\nPackage `gorilla/mux` implements a request router and dispatcher for matching incoming requests to\ntheir respective handler.\n\nThe name mux stands for \"HTTP request multiplexer\". Like the standard `http.ServeMux`, `mux.Router` matches incoming requests against a list of registered routes and calls a handler for the route that matches the URL or other conditions. The main features are:\n\n* It implements the `http.Handler` interface so it is compatible with the standard `http.ServeMux`.\n* Requests can be matched based on URL host, path, path prefix, schemes, header and query values, HTTP methods or using custom matchers.\n* URL hosts, paths and query values can have variables with an optional regular expression.\n* Registered URLs can be built, or \"reversed\", which helps maintaining references to resources.\n* Routes can be used as subrouters: nested routes are only tested if the parent route matches. This is useful to define groups of routes that share common conditions like a host, a path prefix or other repeated attributes. As a bonus, this optimizes request matching.\n\n---\n\n* [Install](#install)\n* [Examples](#examples)\n* [Matching Routes](#matching-routes)\n* [Static Files](#static-files)\n* [Serving Single Page Applications](#serving-single-page-applications) (e.g. React, Vue, Ember.js, etc.)\n* [Registered URLs](#registered-urls)\n* [Walking Routes](#walking-routes)\n* [Graceful Shutdown](#graceful-shutdown)\n* [Middleware](#middleware)\n* [Handling CORS Requests](#handling-cors-requests)\n* [Testing Handlers](#testing-handlers)\n* [Full Example](#full-example)\n\n---\n\n## Install\n\nWith a [correctly configured](https://golang.org/doc/install#testing) Go toolchain:\n\n```sh\ngo get -u github.com/gorilla/mux\n```\n\n## Examples\n\nLet's start registering a couple of URL paths and handlers:\n\n```go\nfunc main() {\n r := mux.NewRouter()\n r.HandleFunc(\"/\", HomeHandler)\n r.HandleFunc(\"/products\", ProductsHandler)\n r.HandleFunc(\"/articles\", ArticlesHandler)\n http.Handle(\"/\", r)\n}\n```\n\nHere we register three routes mapping URL paths to handlers. This is equivalent to how `http.HandleFunc()` works: if an incoming request URL matches one of the paths, the corresponding handler is called passing (`http.ResponseWriter`, `*http.Request`) as parameters.\n\nPaths can have variables. They are defined using the format `{name}` or `{name:pattern}`. If a regular expression pattern is not defined, the matched variable will be anything until the next slash. For example:\n\n```go\nr := mux.NewRouter()\nr.HandleFunc(\"/products/{key}\", ProductHandler)\nr.HandleFunc(\"/articles/{category}/\", ArticlesCategoryHandler)\nr.HandleFunc(\"/articles/{category}/{id:[0-9]+}\", ArticleHandler)\n```\n\nThe names are used to create a map of route variables which can be retrieved calling `mux.Vars()`:\n\n```go\nfunc ArticlesCategoryHandler(w http.ResponseWriter, r *http.Request) {\n vars := mux.Vars(r)\n w.WriteHeader(http.StatusOK)\n fmt.Fprintf(w, \"Category: %v\\n\", vars[\"category\"])\n}\n```\n\nAnd this is all you need to know about the basic usage. More advanced options are explained below.\n\n### Matching Routes\n\nRoutes can also be restricted to a domain or subdomain. Just define a host pattern to be matched. They can also have variables:\n\n```go\nr := mux.NewRouter()\n// Only matches if domain is \"www.example.com\".\nr.Host(\"www.example.com\")\n// Matches a dynamic subdomain.\nr.Host(\"{subdomain:[a-z]+}.example.com\")\n```\n\nThere are several other matchers that can be added. To match path prefixes:\n\n```go\nr.PathPrefix(\"/products/\")\n```\n\n...or HTTP methods:\n\n```go\nr.Methods(\"GET\", \"POST\")\n```\n\n...or URL schemes:\n\n```go\nr.Schemes(\"https\")\n```\n\n...or header values:\n\n```go\nr.Headers(\"X-Requested-With\", \"XMLHttpRequest\")\n```\n\n...or query values:\n\n```go\nr.Queries(\"key\", \"value\")\n```\n\n...or to use a custom matcher function:\n\n```go\nr.MatcherFunc(func(r *http.Request, rm *RouteMatch) bool {\n return r.ProtoMajor == 0\n})\n```\n\n...and finally, it is possible to combine several matchers in a single route:\n\n```go\nr.HandleFunc(\"/products\", ProductsHandler).\n Host(\"www.example.com\").\n Methods(\"GET\").\n Schemes(\"http\")\n```\n\nRoutes are tested in the order they were added to the router. If two routes match, the first one wins:\n\n```go\nr := mux.NewRouter()\nr.HandleFunc(\"/specific\", specificHandler)\nr.PathPrefix(\"/\").Handler(catchAllHandler)\n```\n\nSetting the same matching conditions again and again can be boring, so we have a way to group several routes that share the same requirements. We call it \"subrouting\".\n\nFor example, let's say we have several URLs that should only match when the host is `www.example.com`. Create a route for that host and get a \"subrouter\" from it:\n\n```go\nr := mux.NewRouter()\ns := r.Host(\"www.example.com\").Subrouter()\n```\n\nThen register routes in the subrouter:\n\n```go\ns.HandleFunc(\"/products/\", ProductsHandler)\ns.HandleFunc(\"/products/{key}\", ProductHandler)\ns.HandleFunc(\"/articles/{category}/{id:[0-9]+}\", ArticleHandler)\n```\n\nThe three URL paths we registered above will only be tested if the domain is `www.example.com`, because the subrouter is tested first. This is not only convenient, but also optimizes request matching. You can create subrouters combining any attribute matchers accepted by a route.\n\nSubrouters can be used to create domain or path \"namespaces\": you define subrouters in a central place and then parts of the app can register its paths relatively to a given subrouter.\n\nThere's one more thing about subroutes. When a subrouter has a path prefix, the inner routes use it as base for their paths:\n\n```go\nr := mux.NewRouter()\ns := r.PathPrefix(\"/products\").Subrouter()\n// \"/products/\"\ns.HandleFunc(\"/\", ProductsHandler)\n// \"/products/{key}/\"\ns.HandleFunc(\"/{key}/\", ProductHandler)\n// \"/products/{key}/details\"\ns.HandleFunc(\"/{key}/details\", ProductDetailsHandler)\n```\n\n\n### Static Files\n\nNote that the path provided to `PathPrefix()` represents a \"wildcard\": calling\n`PathPrefix(\"/static/\").Handler(...)` means that the handler will be passed any\nrequest that matches \"/static/\\*\". This makes it easy to serve static files with mux:\n\n```go\nfunc main() {\n var dir string\n\n flag.StringVar(&dir, \"dir\", \".\", \"the directory to serve files from. Defaults to the current dir\")\n flag.Parse()\n r := mux.NewRouter()\n\n // This will serve files under http://localhost:8000/static/\n r.PathPrefix(\"/static/\").Handler(http.StripPrefix(\"/static/\", http.FileServer(http.Dir(dir))))\n\n srv := &http.Server{\n Handler: r,\n Addr: \"127.0.0.1:8000\",\n // Good practice: enforce timeouts for servers you create!\n WriteTimeout: 15 * time.Second,\n ReadTimeout: 15 * time.Second,\n }\n\n log.Fatal(srv.ListenAndServe())\n}\n```\n\n### Serving Single Page Applications\n\nMost of the time it makes sense to serve your SPA on a separate web server from your API,\nbut sometimes it's desirable to serve them both from one place. It's possible to write a simple\nhandler for serving your SPA (for use with React Router's [BrowserRouter](https://reacttraining.com/react-router/web/api/BrowserRouter) for example), and leverage\nmux's powerful routing for your API endpoints.\n\n```go\npackage main\n\nimport (\n\t\"encoding/json\"\n\t\"log\"\n\t\"net/http\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"time\"\n\n\t\"github.com/gorilla/mux\"\n)\n\n// spaHandler implements the http.Handler interface, so we can use it\n// to respond to HTTP requests. The path to the static directory and\n// path to the index file within that static directory are used to\n// serve the SPA in the given static directory.\ntype spaHandler struct {\n\tstaticPath string\n\tindexPath string\n}\n\n// ServeHTTP inspects the URL path to locate a file within the static dir\n// on the SPA handler. If a file is found, it will be served. If not, the\n// file located at the index path on the SPA handler will be served. This\n// is suitable behavior for serving an SPA (single page application).\nfunc (h spaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {\n\t// Join internally call path.Clean to prevent directory traversal\n\tpath := filepath.Join(h.staticPath, r.URL.Path)\n\n\t// check whether a file exists or is a directory at the given path\n\tfi, err := os.Stat(path)\n\tif os.IsNotExist(err) || fi.IsDir() {\n\t\t// file does not exist or path is a directory, serve index.html\n\t\thttp.ServeFile(w, r, filepath.Join(h.staticPath, h.indexPath))\n\t\treturn\n\t}\n\n\tif err != nil {\n\t\t// if we got an error (that wasn't that the file doesn't exist) stating the\n\t\t// file, return a 500 internal server error and stop\n\t\thttp.Error(w, err.Error(), http.StatusInternalServerError)\n return\n\t}\n\n\t// otherwise, use http.FileServer to serve the static file\n\thttp.FileServer(http.Dir(h.staticPath)).ServeHTTP(w, r)\n}\n\nfunc main() {\n\trouter := mux.NewRouter()\n\n\trouter.HandleFunc(\"/api/health\", func(w http.ResponseWriter, r *http.Request) {\n\t\t// an example API handler\n\t\tjson.NewEncoder(w).Encode(map[string]bool{\"ok\": true})\n\t})\n\n\tspa := spaHandler{staticPath: \"build\", indexPath: \"index.html\"}\n\trouter.PathPrefix(\"/\").Handler(spa)\n\n\tsrv := &http.Server{\n\t\tHandler: router,\n\t\tAddr: \"127.0.0.1:8000\",\n\t\t// Good practice: enforce timeouts for servers you create!\n\t\tWriteTimeout: 15 * time.Second,\n\t\tReadTimeout: 15 * time.Second,\n\t}\n\n\tlog.Fatal(srv.ListenAndServe())\n}\n```\n\n### Registered URLs\n\nNow let's see how to build registered URLs.\n\nRoutes can be named. All routes that define a name can have their URLs built, or \"reversed\". We define a name calling `Name()` on a route. For example:\n\n```go\nr := mux.NewRouter()\nr.HandleFunc(\"/articles/{category}/{id:[0-9]+}\", ArticleHandler).\n Name(\"article\")\n```\n\nTo build a URL, get the route and call the `URL()` method, passing a sequence of key/value pairs for the route variables. For the previous route, we would do:\n\n```go\nurl, err := r.Get(\"article\").URL(\"category\", \"technology\", \"id\", \"42\")\n```\n\n...and the result will be a `url.URL` with the following path:\n\n```\n\"/articles/technology/42\"\n```\n\nThis also works for host and query value variables:\n\n```go\nr := mux.NewRouter()\nr.Host(\"{subdomain}.example.com\").\n Path(\"/articles/{category}/{id:[0-9]+}\").\n Queries(\"filter\", \"{filter}\").\n HandlerFunc(ArticleHandler).\n Name(\"article\")\n\n// url.String() will be \"http://news.example.com/articles/technology/42?filter=gorilla\"\nurl, err := r.Get(\"article\").URL(\"subdomain\", \"news\",\n \"category\", \"technology\",\n \"id\", \"42\",\n \"filter\", \"gorilla\")\n```\n\nAll variables defined in the route are required, and their values must conform to the corresponding patterns. These requirements guarantee that a generated URL will always match a registered route -- the only exception is for explicitly defined \"build-only\" routes which never match.\n\nRegex support also exists for matching Headers within a route. For example, we could do:\n\n```go\nr.HeadersRegexp(\"Content-Type\", \"application/(text|json)\")\n```\n\n...and the route will match both requests with a Content-Type of `application/json` as well as `application/text`\n\nThere's also a way to build only the URL host or path for a route: use the methods `URLHost()` or `URLPath()` instead. For the previous route, we would do:\n\n```go\n// \"http://news.example.com/\"\nhost, err := r.Get(\"article\").URLHost(\"subdomain\", \"news\")\n\n// \"/articles/technology/42\"\npath, err := r.Get(\"article\").URLPath(\"category\", \"technology\", \"id\", \"42\")\n```\n\nAnd if you use subrouters, host and path defined separately can be built as well:\n\n```go\nr := mux.NewRouter()\ns := r.Host(\"{subdomain}.example.com\").Subrouter()\ns.Path(\"/articles/{category}/{id:[0-9]+}\").\n HandlerFunc(ArticleHandler).\n Name(\"article\")\n\n// \"http://news.example.com/articles/technology/42\"\nurl, err := r.Get(\"article\").URL(\"subdomain\", \"news\",\n \"category\", \"technology\",\n \"id\", \"42\")\n```\n\nTo find all the required variables for a given route when calling `URL()`, the method `GetVarNames()` is available:\n```go\nr := mux.NewRouter()\nr.Host(\"{domain}\").\n Path(\"/{group}/{item_id}\").\n Queries(\"some_data1\", \"{some_data1}\").\n Queries(\"some_data2\", \"{some_data2}\").\n Name(\"article\")\n\n// Will print [domain group item_id some_data1 some_data2] \nfmt.Println(r.Get(\"article\").GetVarNames())\n\n```\n### Walking Routes\n\nThe `Walk` function on `mux.Router` can be used to visit all of the routes that are registered on a router. For example,\nthe following prints all of the registered routes:\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n\t\"strings\"\n\n\t\"github.com/gorilla/mux\"\n)\n\nfunc handler(w http.ResponseWriter, r *http.Request) {\n\treturn\n}\n\nfunc main() {\n\tr := mux.NewRouter()\n\tr.HandleFunc(\"/\", handler)\n\tr.HandleFunc(\"/products\", handler).Methods(\"POST\")\n\tr.HandleFunc(\"/articles\", handler).Methods(\"GET\")\n\tr.HandleFunc(\"/articles/{id}\", handler).Methods(\"GET\", \"PUT\")\n\tr.HandleFunc(\"/authors\", handler).Queries(\"surname\", \"{surname}\")\n\terr := r.Walk(func(route *mux.Route, router *mux.Router, ancestors []*mux.Route) error {\n\t\tpathTemplate, err := route.GetPathTemplate()\n\t\tif err == nil {\n\t\t\tfmt.Println(\"ROUTE:\", pathTemplate)\n\t\t}\n\t\tpathRegexp, err := route.GetPathRegexp()\n\t\tif err == nil {\n\t\t\tfmt.Println(\"Path regexp:\", pathRegexp)\n\t\t}\n\t\tqueriesTemplates, err := route.GetQueriesTemplates()\n\t\tif err == nil {\n\t\t\tfmt.Println(\"Queries templates:\", strings.Join(queriesTemplates, \",\"))\n\t\t}\n\t\tqueriesRegexps, err := route.GetQueriesRegexp()\n\t\tif err == nil {\n\t\t\tfmt.Println(\"Queries regexps:\", strings.Join(queriesRegexps, \",\"))\n\t\t}\n\t\tmethods, err := route.GetMethods()\n\t\tif err == nil {\n\t\t\tfmt.Println(\"Methods:\", strings.Join(methods, \",\"))\n\t\t}\n\t\tfmt.Println()\n\t\treturn nil\n\t})\n\n\tif err != nil {\n\t\tfmt.Println(err)\n\t}\n\n\thttp.Handle(\"/\", r)\n}\n```\n\n### Graceful Shutdown\n\nGo 1.8 introduced the ability to [gracefully shutdown](https://golang.org/doc/go1.8#http_shutdown) a `*http.Server`. Here's how to do that alongside `mux`:\n\n```go\npackage main\n\nimport (\n \"context\"\n \"flag\"\n \"log\"\n \"net/http\"\n \"os\"\n \"os/signal\"\n \"time\"\n\n \"github.com/gorilla/mux\"\n)\n\nfunc main() {\n var wait time.Duration\n flag.DurationVar(&wait, \"graceful-timeout\", time.Second * 15, \"the duration for which the server gracefully wait for existing connections to finish - e.g. 15s or 1m\")\n flag.Parse()\n\n r := mux.NewRouter()\n // Add your routes as needed\n\n srv := &http.Server{\n Addr: \"0.0.0.0:8080\",\n // Good practice to set timeouts to avoid Slowloris attacks.\n WriteTimeout: time.Second * 15,\n ReadTimeout: time.Second * 15,\n IdleTimeout: time.Second * 60,\n Handler: r, // Pass our instance of gorilla/mux in.\n }\n\n // Run our server in a goroutine so that it doesn't block.\n go func() {\n if err := srv.ListenAndServe(); err != nil {\n log.Println(err)\n }\n }()\n\n c := make(chan os.Signal, 1)\n // We'll accept graceful shutdowns when quit via SIGINT (Ctrl+C)\n // SIGKILL, SIGQUIT or SIGTERM (Ctrl+/) will not be caught.\n signal.Notify(c, os.Interrupt)\n\n // Block until we receive our signal.\n <-c\n\n // Create a deadline to wait for.\n ctx, cancel := context.WithTimeout(context.Background(), wait)\n defer cancel()\n // Doesn't block if no connections, but will otherwise wait\n // until the timeout deadline.\n srv.Shutdown(ctx)\n // Optionally, you could run srv.Shutdown in a goroutine and block on\n // <-ctx.Done() if your application should wait for other services\n // to finalize based on context cancellation.\n log.Println(\"shutting down\")\n os.Exit(0)\n}\n```\n\n### Middleware\n\nMux supports the addition of middlewares to a [Router](https://godoc.org/github.com/gorilla/mux#Router), which are executed in the order they are added if a match is found, including its subrouters.\nMiddlewares are (typically) small pieces of code which take one request, do something with it, and pass it down to another middleware or the final handler. Some common use cases for middleware are request logging, header manipulation, or `ResponseWriter` hijacking.\n\nMux middlewares are defined using the de facto standard type:\n\n```go\ntype MiddlewareFunc func(http.Handler) http.Handler\n```\n\nTypically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed to it, and then calls the handler passed as parameter to the MiddlewareFunc. This takes advantage of closures being able access variables from the context where they are created, while retaining the signature enforced by the receivers.\n\nA very basic middleware which logs the URI of the request being handled could be written as:\n\n```go\nfunc loggingMiddleware(next http.Handler) http.Handler {\n return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n // Do stuff here\n log.Println(r.RequestURI)\n // Call the next handler, which can be another middleware in the chain, or the final handler.\n next.ServeHTTP(w, r)\n })\n}\n```\n\nMiddlewares can be added to a router using `Router.Use()`:\n\n```go\nr := mux.NewRouter()\nr.HandleFunc(\"/\", handler)\nr.Use(loggingMiddleware)\n```\n\nA more complex authentication middleware, which maps session token to users, could be written as:\n\n```go\n// Define our struct\ntype authenticationMiddleware struct {\n\ttokenUsers map[string]string\n}\n\n// Initialize it somewhere\nfunc (amw *authenticationMiddleware) Populate() {\n\tamw.tokenUsers[\"00000000\"] = \"user0\"\n\tamw.tokenUsers[\"aaaaaaaa\"] = \"userA\"\n\tamw.tokenUsers[\"05f717e5\"] = \"randomUser\"\n\tamw.tokenUsers[\"deadbeef\"] = \"user0\"\n}\n\n// Middleware function, which will be called for each request\nfunc (amw *authenticationMiddleware) Middleware(next http.Handler) http.Handler {\n return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n token := r.Header.Get(\"X-Session-Token\")\n\n if user, found := amw.tokenUsers[token]; found {\n \t// We found the token in our map\n \tlog.Printf(\"Authenticated user %s\\n\", user)\n \t// Pass down the request to the next middleware (or final handler)\n \tnext.ServeHTTP(w, r)\n } else {\n \t// Write an error and stop the handler chain\n \thttp.Error(w, \"Forbidden\", http.StatusForbidden)\n }\n })\n}\n```\n\n```go\nr := mux.NewRouter()\nr.HandleFunc(\"/\", handler)\n\namw := authenticationMiddleware{tokenUsers: make(map[string]string)}\namw.Populate()\n\nr.Use(amw.Middleware)\n```\n\nNote: The handler chain will be stopped if your middleware doesn't call `next.ServeHTTP()` with the corresponding parameters. This can be used to abort a request if the middleware writer wants to. Middlewares _should_ write to `ResponseWriter` if they _are_ going to terminate the request, and they _should not_ write to `ResponseWriter` if they _are not_ going to terminate it.\n\n### Handling CORS Requests\n\n[CORSMethodMiddleware](https://godoc.org/github.com/gorilla/mux#CORSMethodMiddleware) intends to make it easier to strictly set the `Access-Control-Allow-Methods` response header.\n\n* You will still need to use your own CORS handler to set the other CORS headers such as `Access-Control-Allow-Origin`\n* The middleware will set the `Access-Control-Allow-Methods` header to all the method matchers (e.g. `r.Methods(http.MethodGet, http.MethodPut, http.MethodOptions)` -> `Access-Control-Allow-Methods: GET,PUT,OPTIONS`) on a route\n* If you do not specify any methods, then:\n> _Important_: there must be an `OPTIONS` method matcher for the middleware to set the headers.\n\nHere is an example of using `CORSMethodMiddleware` along with a custom `OPTIONS` handler to set all the required CORS headers:\n\n```go\npackage main\n\nimport (\n\t\"net/http\"\n\t\"github.com/gorilla/mux\"\n)\n\nfunc main() {\n r := mux.NewRouter()\n\n // IMPORTANT: you must specify an OPTIONS method matcher for the middleware to set CORS headers\n r.HandleFunc(\"/foo\", fooHandler).Methods(http.MethodGet, http.MethodPut, http.MethodPatch, http.MethodOptions)\n r.Use(mux.CORSMethodMiddleware(r))\n \n http.ListenAndServe(\":8080\", r)\n}\n\nfunc fooHandler(w http.ResponseWriter, r *http.Request) {\n w.Header().Set(\"Access-Control-Allow-Origin\", \"*\")\n if r.Method == http.MethodOptions {\n return\n }\n\n w.Write([]byte(\"foo\"))\n}\n```\n\nAnd an request to `/foo` using something like:\n\n```bash\ncurl localhost:8080/foo -v\n```\n\nWould look like:\n\n```bash\n* Trying ::1...\n* TCP_NODELAY set\n* Connected to localhost (::1) port 8080 (#0)\n> GET /foo HTTP/1.1\n> Host: localhost:8080\n> User-Agent: curl/7.59.0\n> Accept: */*\n> \n< HTTP/1.1 200 OK\n< Access-Control-Allow-Methods: GET,PUT,PATCH,OPTIONS\n< Access-Control-Allow-Origin: *\n< Date: Fri, 28 Jun 2019 20:13:30 GMT\n< Content-Length: 3\n< Content-Type: text/plain; charset=utf-8\n< \n* Connection #0 to host localhost left intact\nfoo\n```\n\n### Testing Handlers\n\nTesting handlers in a Go web application is straightforward, and _mux_ doesn't complicate this any further. Given two files: `endpoints.go` and `endpoints_test.go`, here's how we'd test an application using _mux_.\n\nFirst, our simple HTTP handler:\n\n```go\n// endpoints.go\npackage main\n\nfunc HealthCheckHandler(w http.ResponseWriter, r *http.Request) {\n // A very simple health check.\n w.Header().Set(\"Content-Type\", \"application/json\")\n w.WriteHeader(http.StatusOK)\n\n // In the future we could report back on the status of our DB, or our cache\n // (e.g. Redis) by performing a simple PING, and include them in the response.\n io.WriteString(w, `{\"alive\": true}`)\n}\n\nfunc main() {\n r := mux.NewRouter()\n r.HandleFunc(\"/health\", HealthCheckHandler)\n\n log.Fatal(http.ListenAndServe(\"localhost:8080\", r))\n}\n```\n\nOur test code:\n\n```go\n// endpoints_test.go\npackage main\n\nimport (\n \"net/http\"\n \"net/http/httptest\"\n \"testing\"\n)\n\nfunc TestHealthCheckHandler(t *testing.T) {\n // Create a request to pass to our handler. We don't have any query parameters for now, so we'll\n // pass 'nil' as the third parameter.\n req, err := http.NewRequest(\"GET\", \"/health\", nil)\n if err != nil {\n t.Fatal(err)\n }\n\n // We create a ResponseRecorder (which satisfies http.ResponseWriter) to record the response.\n rr := httptest.NewRecorder()\n handler := http.HandlerFunc(HealthCheckHandler)\n\n // Our handlers satisfy http.Handler, so we can call their ServeHTTP method\n // directly and pass in our Request and ResponseRecorder.\n handler.ServeHTTP(rr, req)\n\n // Check the status code is what we expect.\n if status := rr.Code; status != http.StatusOK {\n t.Errorf(\"handler returned wrong status code: got %v want %v\",\n status, http.StatusOK)\n }\n\n // Check the response body is what we expect.\n expected := `{\"alive\": true}`\n if rr.Body.String() != expected {\n t.Errorf(\"handler returned unexpected body: got %v want %v\",\n rr.Body.String(), expected)\n }\n}\n```\n\nIn the case that our routes have [variables](#examples), we can pass those in the request. We could write\n[table-driven tests](https://dave.cheney.net/2013/06/09/writing-table-driven-tests-in-go) to test multiple\npossible route variables as needed.\n\n```go\n// endpoints.go\nfunc main() {\n r := mux.NewRouter()\n // A route with a route variable:\n r.HandleFunc(\"/metrics/{type}\", MetricsHandler)\n\n log.Fatal(http.ListenAndServe(\"localhost:8080\", r))\n}\n```\n\nOur test file, with a table-driven test of `routeVariables`:\n\n```go\n// endpoints_test.go\nfunc TestMetricsHandler(t *testing.T) {\n tt := []struct{\n routeVariable string\n shouldPass bool\n }{\n {\"goroutines\", true},\n {\"heap\", true},\n {\"counters\", true},\n {\"queries\", true},\n {\"adhadaeqm3k\", false},\n }\n\n for _, tc := range tt {\n path := fmt.Sprintf(\"/metrics/%s\", tc.routeVariable)\n req, err := http.NewRequest(\"GET\", path, nil)\n if err != nil {\n t.Fatal(err)\n }\n\n rr := httptest.NewRecorder()\n\t\n\t// To add the vars to the context, \n\t// we need to create a router through which we can pass the request.\n\trouter := mux.NewRouter()\n router.HandleFunc(\"/metrics/{type}\", MetricsHandler)\n router.ServeHTTP(rr, req)\n\n // In this case, our MetricsHandler returns a non-200 response\n // for a route variable it doesn't know about.\n if rr.Code == http.StatusOK && !tc.shouldPass {\n t.Errorf(\"handler should have failed on routeVariable %s: got %v want %v\",\n tc.routeVariable, rr.Code, http.StatusOK)\n }\n }\n}\n```\n\n## Full Example\n\nHere's a complete, runnable example of a small `mux` based server:\n\n```go\npackage main\n\nimport (\n \"net/http\"\n \"log\"\n \"github.com/gorilla/mux\"\n)\n\nfunc YourHandler(w http.ResponseWriter, r *http.Request) {\n w.Write([]byte(\"Gorilla!\\n\"))\n}\n\nfunc main() {\n r := mux.NewRouter()\n // Routes consist of a path and a handler function.\n r.HandleFunc(\"/\", YourHandler)\n\n // Bind to a port and pass our router in\n log.Fatal(http.ListenAndServe(\":8000\", r))\n}\n```\n\n## License\n\nBSD licensed. See the LICENSE file for details.\n"
},
{
"path": "vendor/github.com/gorilla/mux/doc.go",
"content": "// Copyright 2012 The Gorilla Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n/*\nPackage mux implements a request router and dispatcher.\n\nThe name mux stands for \"HTTP request multiplexer\". Like the standard\nhttp.ServeMux, mux.Router matches incoming requests against a list of\nregistered routes and calls a handler for the route that matches the URL\nor other conditions. The main features are:\n\n - Requests can be matched based on URL host, path, path prefix, schemes,\n header and query values, HTTP methods or using custom matchers.\n - URL hosts, paths and query values can have variables with an optional\n regular expression.\n - Registered URLs can be built, or \"reversed\", which helps maintaining\n references to resources.\n - Routes can be used as subrouters: nested routes are only tested if the\n parent route matches. This is useful to define groups of routes that\n share common conditions like a host, a path prefix or other repeated\n attributes. As a bonus, this optimizes request matching.\n - It implements the http.Handler interface so it is compatible with the\n standard http.ServeMux.\n\nLet's start registering a couple of URL paths and handlers:\n\n\tfunc main() {\n\t\tr := mux.NewRouter()\n\t\tr.HandleFunc(\"/\", HomeHandler)\n\t\tr.HandleFunc(\"/products\", ProductsHandler)\n\t\tr.HandleFunc(\"/articles\", ArticlesHandler)\n\t\thttp.Handle(\"/\", r)\n\t}\n\nHere we register three routes mapping URL paths to handlers. This is\nequivalent to how http.HandleFunc() works: if an incoming request URL matches\none of the paths, the corresponding handler is called passing\n(http.ResponseWriter, *http.Request) as parameters.\n\nPaths can have variables. They are defined using the format {name} or\n{name:pattern}. If a regular expression pattern is not defined, the matched\nvariable will be anything until the next slash. For example:\n\n\tr := mux.NewRouter()\n\tr.HandleFunc(\"/products/{key}\", ProductHandler)\n\tr.HandleFunc(\"/articles/{category}/\", ArticlesCategoryHandler)\n\tr.HandleFunc(\"/articles/{category}/{id:[0-9]+}\", ArticleHandler)\n\nGroups can be used inside patterns, as long as they are non-capturing (?:re). For example:\n\n\tr.HandleFunc(\"/articles/{category}/{sort:(?:asc|desc|new)}\", ArticlesCategoryHandler)\n\nThe names are used to create a map of route variables which can be retrieved\ncalling mux.Vars():\n\n\tvars := mux.Vars(request)\n\tcategory := vars[\"category\"]\n\nNote that if any capturing groups are present, mux will panic() during parsing. To prevent\nthis, convert any capturing groups to non-capturing, e.g. change \"/{sort:(asc|desc)}\" to\n\"/{sort:(?:asc|desc)}\". This is a change from prior versions which behaved unpredictably\nwhen capturing groups were present.\n\nAnd this is all you need to know about the basic usage. More advanced options\nare explained below.\n\nRoutes can also be restricted to a domain or subdomain. Just define a host\npattern to be matched. They can also have variables:\n\n\tr := mux.NewRouter()\n\t// Only matches if domain is \"www.example.com\".\n\tr.Host(\"www.example.com\")\n\t// Matches a dynamic subdomain.\n\tr.Host(\"{subdomain:[a-z]+}.domain.com\")\n\nThere are several other matchers that can be added. To match path prefixes:\n\n\tr.PathPrefix(\"/products/\")\n\n...or HTTP methods:\n\n\tr.Methods(\"GET\", \"POST\")\n\n...or URL schemes:\n\n\tr.Schemes(\"https\")\n\n...or header values:\n\n\tr.Headers(\"X-Requested-With\", \"XMLHttpRequest\")\n\n...or query values:\n\n\tr.Queries(\"key\", \"value\")\n\n...or to use a custom matcher function:\n\n\tr.MatcherFunc(func(r *http.Request, rm *RouteMatch) bool {\n\t\treturn r.ProtoMajor == 0\n\t})\n\n...and finally, it is possible to combine several matchers in a single route:\n\n\tr.HandleFunc(\"/products\", ProductsHandler).\n\t Host(\"www.example.com\").\n\t Methods(\"GET\").\n\t Schemes(\"http\")\n\nSetting the same matching conditions again and again can be boring, so we have\na way to group several routes that share the same requirements.\nWe call it \"subrouting\".\n\nFor example, let's say we have several URLs that should only match when the\nhost is \"www.example.com\". Create a route for that host and get a \"subrouter\"\nfrom it:\n\n\tr := mux.NewRouter()\n\ts := r.Host(\"www.example.com\").Subrouter()\n\nThen register routes in the subrouter:\n\n\ts.HandleFunc(\"/products/\", ProductsHandler)\n\ts.HandleFunc(\"/products/{key}\", ProductHandler)\n\ts.HandleFunc(\"/articles/{category}/{id:[0-9]+}\"), ArticleHandler)\n\nThe three URL paths we registered above will only be tested if the domain is\n\"www.example.com\", because the subrouter is tested first. This is not\nonly convenient, but also optimizes request matching. You can create\nsubrouters combining any attribute matchers accepted by a route.\n\nSubrouters can be used to create domain or path \"namespaces\": you define\nsubrouters in a central place and then parts of the app can register its\npaths relatively to a given subrouter.\n\nThere's one more thing about subroutes. When a subrouter has a path prefix,\nthe inner routes use it as base for their paths:\n\n\tr := mux.NewRouter()\n\ts := r.PathPrefix(\"/products\").Subrouter()\n\t// \"/products/\"\n\ts.HandleFunc(\"/\", ProductsHandler)\n\t// \"/products/{key}/\"\n\ts.HandleFunc(\"/{key}/\", ProductHandler)\n\t// \"/products/{key}/details\"\n\ts.HandleFunc(\"/{key}/details\", ProductDetailsHandler)\n\nNote that the path provided to PathPrefix() represents a \"wildcard\": calling\nPathPrefix(\"/static/\").Handler(...) means that the handler will be passed any\nrequest that matches \"/static/*\". This makes it easy to serve static files with mux:\n\n\tfunc main() {\n\t\tvar dir string\n\n\t\tflag.StringVar(&dir, \"dir\", \".\", \"the directory to serve files from. Defaults to the current dir\")\n\t\tflag.Parse()\n\t\tr := mux.NewRouter()\n\n\t\t// This will serve files under http://localhost:8000/static/\n\t\tr.PathPrefix(\"/static/\").Handler(http.StripPrefix(\"/static/\", http.FileServer(http.Dir(dir))))\n\n\t\tsrv := &http.Server{\n\t\t\tHandler: r,\n\t\t\tAddr: \"127.0.0.1:8000\",\n\t\t\t// Good practice: enforce timeouts for servers you create!\n\t\t\tWriteTimeout: 15 * time.Second,\n\t\t\tReadTimeout: 15 * time.Second,\n\t\t}\n\n\t\tlog.Fatal(srv.ListenAndServe())\n\t}\n\nNow let's see how to build registered URLs.\n\nRoutes can be named. All routes that define a name can have their URLs built,\nor \"reversed\". We define a name calling Name() on a route. For example:\n\n\tr := mux.NewRouter()\n\tr.HandleFunc(\"/articles/{category}/{id:[0-9]+}\", ArticleHandler).\n\t Name(\"article\")\n\nTo build a URL, get the route and call the URL() method, passing a sequence of\nkey/value pairs for the route variables. For the previous route, we would do:\n\n\turl, err := r.Get(\"article\").URL(\"category\", \"technology\", \"id\", \"42\")\n\n...and the result will be a url.URL with the following path:\n\n\t\"/articles/technology/42\"\n\nThis also works for host and query value variables:\n\n\tr := mux.NewRouter()\n\tr.Host(\"{subdomain}.domain.com\").\n\t Path(\"/articles/{category}/{id:[0-9]+}\").\n\t Queries(\"filter\", \"{filter}\").\n\t HandlerFunc(ArticleHandler).\n\t Name(\"article\")\n\n\t// url.String() will be \"http://news.domain.com/articles/technology/42?filter=gorilla\"\n\turl, err := r.Get(\"article\").URL(\"subdomain\", \"news\",\n\t \"category\", \"technology\",\n\t \"id\", \"42\",\n\t \"filter\", \"gorilla\")\n\nAll variables defined in the route are required, and their values must\nconform to the corresponding patterns. These requirements guarantee that a\ngenerated URL will always match a registered route -- the only exception is\nfor explicitly defined \"build-only\" routes which never match.\n\nRegex support also exists for matching Headers within a route. For example, we could do:\n\n\tr.HeadersRegexp(\"Content-Type\", \"application/(text|json)\")\n\n...and the route will match both requests with a Content-Type of `application/json` as well as\n`application/text`\n\nThere's also a way to build only the URL host or path for a route:\nuse the methods URLHost() or URLPath() instead. For the previous route,\nwe would do:\n\n\t// \"http://news.domain.com/\"\n\thost, err := r.Get(\"article\").URLHost(\"subdomain\", \"news\")\n\n\t// \"/articles/technology/42\"\n\tpath, err := r.Get(\"article\").URLPath(\"category\", \"technology\", \"id\", \"42\")\n\nAnd if you use subrouters, host and path defined separately can be built\nas well:\n\n\tr := mux.NewRouter()\n\ts := r.Host(\"{subdomain}.domain.com\").Subrouter()\n\ts.Path(\"/articles/{category}/{id:[0-9]+}\").\n\t HandlerFunc(ArticleHandler).\n\t Name(\"article\")\n\n\t// \"http://news.domain.com/articles/technology/42\"\n\turl, err := r.Get(\"article\").URL(\"subdomain\", \"news\",\n\t \"category\", \"technology\",\n\t \"id\", \"42\")\n\nMux supports the addition of middlewares to a Router, which are executed in the order they are added if a match is found, including its subrouters. Middlewares are (typically) small pieces of code which take one request, do something with it, and pass it down to another middleware or the final handler. Some common use cases for middleware are request logging, header manipulation, or ResponseWriter hijacking.\n\n\ttype MiddlewareFunc func(http.Handler) http.Handler\n\nTypically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed to it, and then calls the handler passed as parameter to the MiddlewareFunc (closures can access variables from the context where they are created).\n\nA very basic middleware which logs the URI of the request being handled could be written as:\n\n\tfunc simpleMw(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\t// Do stuff here\n\t\t\tlog.Println(r.RequestURI)\n\t\t\t// Call the next handler, which can be another middleware in the chain, or the final handler.\n\t\t\tnext.ServeHTTP(w, r)\n\t\t})\n\t}\n\nMiddlewares can be added to a router using `Router.Use()`:\n\n\tr := mux.NewRouter()\n\tr.HandleFunc(\"/\", handler)\n\tr.Use(simpleMw)\n\nA more complex authentication middleware, which maps session token to users, could be written as:\n\n\t// Define our struct\n\ttype authenticationMiddleware struct {\n\t\ttokenUsers map[string]string\n\t}\n\n\t// Initialize it somewhere\n\tfunc (amw *authenticationMiddleware) Populate() {\n\t\tamw.tokenUsers[\"00000000\"] = \"user0\"\n\t\tamw.tokenUsers[\"aaaaaaaa\"] = \"userA\"\n\t\tamw.tokenUsers[\"05f717e5\"] = \"randomUser\"\n\t\tamw.tokenUsers[\"deadbeef\"] = \"user0\"\n\t}\n\n\t// Middleware function, which will be called for each request\n\tfunc (amw *authenticationMiddleware) Middleware(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {\n\t\t\ttoken := r.Header.Get(\"X-Session-Token\")\n\n\t\t\tif user, found := amw.tokenUsers[token]; found {\n\t\t\t\t// We found the token in our map\n\t\t\t\tlog.Printf(\"Authenticated user %s\\n\", user)\n\t\t\t\tnext.ServeHTTP(w, r)\n\t\t\t} else {\n\t\t\t\thttp.Error(w, \"Forbidden\", http.StatusForbidden)\n\t\t\t}\n\t\t})\n\t}\n\n\tr := mux.NewRouter()\n\tr.HandleFunc(\"/\", handler)\n\n\tamw := authenticationMiddleware{tokenUsers: make(map[string]string)}\n\tamw.Populate()\n\n\tr.Use(amw.Middleware)\n\nNote: The handler chain will be stopped if your middleware doesn't call `next.ServeHTTP()` with the corresponding parameters. This can be used to abort a request if the middleware writer wants to.\n*/\npackage mux\n"
},
{
"path": "vendor/github.com/gorilla/mux/middleware.go",
"content": "package mux\n\nimport (\n\t\"net/http\"\n\t\"strings\"\n)\n\n// MiddlewareFunc is a function which receives an http.Handler and returns another http.Handler.\n// Typically, the returned handler is a closure which does something with the http.ResponseWriter and http.Request passed\n// to it, and then calls the handler passed as parameter to the MiddlewareFunc.\ntype MiddlewareFunc func(http.Handler) http.Handler\n\n// middleware interface is anything which implements a MiddlewareFunc named Middleware.\ntype middleware interface {\n\tMiddleware(handler http.Handler) http.Handler\n}\n\n// Middleware allows MiddlewareFunc to implement the middleware interface.\nfunc (mw MiddlewareFunc) Middleware(handler http.Handler) http.Handler {\n\treturn mw(handler)\n}\n\n// Use appends a MiddlewareFunc to the chain. Middleware can be used to intercept or otherwise modify requests and/or responses, and are executed in the order that they are applied to the Router.\nfunc (r *Router) Use(mwf ...MiddlewareFunc) {\n\tfor _, fn := range mwf {\n\t\tr.middlewares = append(r.middlewares, fn)\n\t}\n}\n\n// useInterface appends a middleware to the chain. Middleware can be used to intercept or otherwise modify requests and/or responses, and are executed in the order that they are applied to the Router.\nfunc (r *Router) useInterface(mw middleware) {\n\tr.middlewares = append(r.middlewares, mw)\n}\n\n// CORSMethodMiddleware automatically sets the Access-Control-Allow-Methods response header\n// on requests for routes that have an OPTIONS method matcher to all the method matchers on\n// the route. Routes that do not explicitly handle OPTIONS requests will not be processed\n// by the middleware. See examples for usage.\nfunc CORSMethodMiddleware(r *Router) MiddlewareFunc {\n\treturn func(next http.Handler) http.Handler {\n\t\treturn http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {\n\t\t\tallMethods, err := getAllMethodsForRoute(r, req)\n\t\t\tif err == nil {\n\t\t\t\tfor _, v := range allMethods {\n\t\t\t\t\tif v == http.MethodOptions {\n\t\t\t\t\t\tw.Header().Set(\"Access-Control-Allow-Methods\", strings.Join(allMethods, \",\"))\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tnext.ServeHTTP(w, req)\n\t\t})\n\t}\n}\n\n// getAllMethodsForRoute returns all the methods from method matchers matching a given\n// request.\nfunc getAllMethodsForRoute(r *Router, req *http.Request) ([]string, error) {\n\tvar allMethods []string\n\n\tfor _, route := range r.routes {\n\t\tvar match RouteMatch\n\t\tif route.Match(req, &match) || match.MatchErr == ErrMethodMismatch {\n\t\t\tmethods, err := route.GetMethods()\n\t\t\tif err != nil {\n\t\t\t\treturn nil, err\n\t\t\t}\n\n\t\t\tallMethods = append(allMethods, methods...)\n\t\t}\n\t}\n\n\treturn allMethods, nil\n}\n"
},
{
"path": "vendor/github.com/gorilla/mux/mux.go",
"content": "// Copyright 2012 The Gorilla Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage mux\n\nimport (\n\t\"context\"\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"path\"\n\t\"regexp\"\n)\n\nvar (\n\t// ErrMethodMismatch is returned when the method in the request does not match\n\t// the method defined against the route.\n\tErrMethodMismatch = errors.New(\"method is not allowed\")\n\t// ErrNotFound is returned when no route match is found.\n\tErrNotFound = errors.New(\"no matching route was found\")\n)\n\n// NewRouter returns a new router instance.\nfunc NewRouter() *Router {\n\treturn &Router{namedRoutes: make(map[string]*Route)}\n}\n\n// Router registers routes to be matched and dispatches a handler.\n//\n// It implements the http.Handler interface, so it can be registered to serve\n// requests:\n//\n//\tvar router = mux.NewRouter()\n//\n//\tfunc main() {\n//\t http.Handle(\"/\", router)\n//\t}\n//\n// Or, for Google App Engine, register it in a init() function:\n//\n//\tfunc init() {\n//\t http.Handle(\"/\", router)\n//\t}\n//\n// This will send all incoming requests to the router.\ntype Router struct {\n\t// Configurable Handler to be used when no route matches.\n\t// This can be used to render your own 404 Not Found errors.\n\tNotFoundHandler http.Handler\n\n\t// Configurable Handler to be used when the request method does not match the route.\n\t// This can be used to render your own 405 Method Not Allowed errors.\n\tMethodNotAllowedHandler http.Handler\n\n\t// Routes to be matched, in order.\n\troutes []*Route\n\n\t// Routes by name for URL building.\n\tnamedRoutes map[string]*Route\n\n\t// If true, do not clear the request context after handling the request.\n\t//\n\t// Deprecated: No effect, since the context is stored on the request itself.\n\tKeepContext bool\n\n\t// Slice of middlewares to be called after a match is found\n\tmiddlewares []middleware\n\n\t// configuration shared with `Route`\n\trouteConf\n}\n\n// common route configuration shared between `Router` and `Route`\ntype routeConf struct {\n\t// If true, \"/path/foo%2Fbar/to\" will match the path \"/path/{var}/to\"\n\tuseEncodedPath bool\n\n\t// If true, when the path pattern is \"/path/\", accessing \"/path\" will\n\t// redirect to the former and vice versa.\n\tstrictSlash bool\n\n\t// If true, when the path pattern is \"/path//to\", accessing \"/path//to\"\n\t// will not redirect\n\tskipClean bool\n\n\t// Manager for the variables from host and path.\n\tregexp routeRegexpGroup\n\n\t// List of matchers.\n\tmatchers []matcher\n\n\t// The scheme used when building URLs.\n\tbuildScheme string\n\n\tbuildVarsFunc BuildVarsFunc\n}\n\n// returns an effective deep copy of `routeConf`\nfunc copyRouteConf(r routeConf) routeConf {\n\tc := r\n\n\tif r.regexp.path != nil {\n\t\tc.regexp.path = copyRouteRegexp(r.regexp.path)\n\t}\n\n\tif r.regexp.host != nil {\n\t\tc.regexp.host = copyRouteRegexp(r.regexp.host)\n\t}\n\n\tc.regexp.queries = make([]*routeRegexp, 0, len(r.regexp.queries))\n\tfor _, q := range r.regexp.queries {\n\t\tc.regexp.queries = append(c.regexp.queries, copyRouteRegexp(q))\n\t}\n\n\tc.matchers = make([]matcher, len(r.matchers))\n\tcopy(c.matchers, r.matchers)\n\n\treturn c\n}\n\nfunc copyRouteRegexp(r *routeRegexp) *routeRegexp {\n\tc := *r\n\treturn &c\n}\n\n// Match attempts to match the given request against the router's registered routes.\n//\n// If the request matches a route of this router or one of its subrouters the Route,\n// Handler, and Vars fields of the the match argument are filled and this function\n// returns true.\n//\n// If the request does not match any of this router's or its subrouters' routes\n// then this function returns false. If available, a reason for the match failure\n// will be filled in the match argument's MatchErr field. If the match failure type\n// (eg: not found) has a registered handler, the handler is assigned to the Handler\n// field of the match argument.\nfunc (r *Router) Match(req *http.Request, match *RouteMatch) bool {\n\tfor _, route := range r.routes {\n\t\tif route.Match(req, match) {\n\t\t\t// Build middleware chain if no error was found\n\t\t\tif match.MatchErr == nil {\n\t\t\t\tfor i := len(r.middlewares) - 1; i >= 0; i-- {\n\t\t\t\t\tmatch.Handler = r.middlewares[i].Middleware(match.Handler)\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true\n\t\t}\n\t}\n\n\tif match.MatchErr == ErrMethodMismatch {\n\t\tif r.MethodNotAllowedHandler != nil {\n\t\t\tmatch.Handler = r.MethodNotAllowedHandler\n\t\t\treturn true\n\t\t}\n\n\t\treturn false\n\t}\n\n\t// Closest match for a router (includes sub-routers)\n\tif r.NotFoundHandler != nil {\n\t\tmatch.Handler = r.NotFoundHandler\n\t\tmatch.MatchErr = ErrNotFound\n\t\treturn true\n\t}\n\n\tmatch.MatchErr = ErrNotFound\n\treturn false\n}\n\n// ServeHTTP dispatches the handler registered in the matched route.\n//\n// When there is a match, the route variables can be retrieved calling\n// mux.Vars(request).\nfunc (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {\n\tif !r.skipClean {\n\t\tpath := req.URL.Path\n\t\tif r.useEncodedPath {\n\t\t\tpath = req.URL.EscapedPath()\n\t\t}\n\t\t// Clean path to canonical form and redirect.\n\t\tif p := cleanPath(path); p != path {\n\n\t\t\t// Added 3 lines (Philip Schlump) - It was dropping the query string and #whatever from query.\n\t\t\t// This matches with fix in go 1.2 r.c. 4 for same problem. Go Issue:\n\t\t\t// http://code.google.com/p/go/issues/detail?id=5252\n\t\t\turl := *req.URL\n\t\t\turl.Path = p\n\t\t\tp = url.String()\n\n\t\t\tw.Header().Set(\"Location\", p)\n\t\t\tw.WriteHeader(http.StatusMovedPermanently)\n\t\t\treturn\n\t\t}\n\t}\n\tvar match RouteMatch\n\tvar handler http.Handler\n\tif r.Match(req, &match) {\n\t\thandler = match.Handler\n\t\treq = requestWithVars(req, match.Vars)\n\t\treq = requestWithRoute(req, match.Route)\n\t}\n\n\tif handler == nil && match.MatchErr == ErrMethodMismatch {\n\t\thandler = methodNotAllowedHandler()\n\t}\n\n\tif handler == nil {\n\t\thandler = http.NotFoundHandler()\n\t}\n\n\thandler.ServeHTTP(w, req)\n}\n\n// Get returns a route registered with the given name.\nfunc (r *Router) Get(name string) *Route {\n\treturn r.namedRoutes[name]\n}\n\n// GetRoute returns a route registered with the given name. This method\n// was renamed to Get() and remains here for backwards compatibility.\nfunc (r *Router) GetRoute(name string) *Route {\n\treturn r.namedRoutes[name]\n}\n\n// StrictSlash defines the trailing slash behavior for new routes. The initial\n// value is false.\n//\n// When true, if the route path is \"/path/\", accessing \"/path\" will perform a redirect\n// to the former and vice versa. In other words, your application will always\n// see the path as specified in the route.\n//\n// When false, if the route path is \"/path\", accessing \"/path/\" will not match\n// this route and vice versa.\n//\n// The re-direct is a HTTP 301 (Moved Permanently). Note that when this is set for\n// routes with a non-idempotent method (e.g. POST, PUT), the subsequent re-directed\n// request will be made as a GET by most clients. Use middleware or client settings\n// to modify this behaviour as needed.\n//\n// Special case: when a route sets a path prefix using the PathPrefix() method,\n// strict slash is ignored for that route because the redirect behavior can't\n// be determined from a prefix alone. However, any subrouters created from that\n// route inherit the original StrictSlash setting.\nfunc (r *Router) StrictSlash(value bool) *Router {\n\tr.strictSlash = value\n\treturn r\n}\n\n// SkipClean defines the path cleaning behaviour for new routes. The initial\n// value is false. Users should be careful about which routes are not cleaned\n//\n// When true, if the route path is \"/path//to\", it will remain with the double\n// slash. This is helpful if you have a route like: /fetch/http://xkcd.com/534/\n//\n// When false, the path will be cleaned, so /fetch/http://xkcd.com/534/ will\n// become /fetch/http/xkcd.com/534\nfunc (r *Router) SkipClean(value bool) *Router {\n\tr.skipClean = value\n\treturn r\n}\n\n// UseEncodedPath tells the router to match the encoded original path\n// to the routes.\n// For eg. \"/path/foo%2Fbar/to\" will match the path \"/path/{var}/to\".\n//\n// If not called, the router will match the unencoded path to the routes.\n// For eg. \"/path/foo%2Fbar/to\" will match the path \"/path/foo/bar/to\"\nfunc (r *Router) UseEncodedPath() *Router {\n\tr.useEncodedPath = true\n\treturn r\n}\n\n// ----------------------------------------------------------------------------\n// Route factories\n// ----------------------------------------------------------------------------\n\n// NewRoute registers an empty route.\nfunc (r *Router) NewRoute() *Route {\n\t// initialize a route with a copy of the parent router's configuration\n\troute := &Route{routeConf: copyRouteConf(r.routeConf), namedRoutes: r.namedRoutes}\n\tr.routes = append(r.routes, route)\n\treturn route\n}\n\n// Name registers a new route with a name.\n// See Route.Name().\nfunc (r *Router) Name(name string) *Route {\n\treturn r.NewRoute().Name(name)\n}\n\n// Handle registers a new route with a matcher for the URL path.\n// See Route.Path() and Route.Handler().\nfunc (r *Router) Handle(path string, handler http.Handler) *Route {\n\treturn r.NewRoute().Path(path).Handler(handler)\n}\n\n// HandleFunc registers a new route with a matcher for the URL path.\n// See Route.Path() and Route.HandlerFunc().\nfunc (r *Router) HandleFunc(path string, f func(http.ResponseWriter,\n\t*http.Request)) *Route {\n\treturn r.NewRoute().Path(path).HandlerFunc(f)\n}\n\n// Headers registers a new route with a matcher for request header values.\n// See Route.Headers().\nfunc (r *Router) Headers(pairs ...string) *Route {\n\treturn r.NewRoute().Headers(pairs...)\n}\n\n// Host registers a new route with a matcher for the URL host.\n// See Route.Host().\nfunc (r *Router) Host(tpl string) *Route {\n\treturn r.NewRoute().Host(tpl)\n}\n\n// MatcherFunc registers a new route with a custom matcher function.\n// See Route.MatcherFunc().\nfunc (r *Router) MatcherFunc(f MatcherFunc) *Route {\n\treturn r.NewRoute().MatcherFunc(f)\n}\n\n// Methods registers a new route with a matcher for HTTP methods.\n// See Route.Methods().\nfunc (r *Router) Methods(methods ...string) *Route {\n\treturn r.NewRoute().Methods(methods...)\n}\n\n// Path registers a new route with a matcher for the URL path.\n// See Route.Path().\nfunc (r *Router) Path(tpl string) *Route {\n\treturn r.NewRoute().Path(tpl)\n}\n\n// PathPrefix registers a new route with a matcher for the URL path prefix.\n// See Route.PathPrefix().\nfunc (r *Router) PathPrefix(tpl string) *Route {\n\treturn r.NewRoute().PathPrefix(tpl)\n}\n\n// Queries registers a new route with a matcher for URL query values.\n// See Route.Queries().\nfunc (r *Router) Queries(pairs ...string) *Route {\n\treturn r.NewRoute().Queries(pairs...)\n}\n\n// Schemes registers a new route with a matcher for URL schemes.\n// See Route.Schemes().\nfunc (r *Router) Schemes(schemes ...string) *Route {\n\treturn r.NewRoute().Schemes(schemes...)\n}\n\n// BuildVarsFunc registers a new route with a custom function for modifying\n// route variables before building a URL.\nfunc (r *Router) BuildVarsFunc(f BuildVarsFunc) *Route {\n\treturn r.NewRoute().BuildVarsFunc(f)\n}\n\n// Walk walks the router and all its sub-routers, calling walkFn for each route\n// in the tree. The routes are walked in the order they were added. Sub-routers\n// are explored depth-first.\nfunc (r *Router) Walk(walkFn WalkFunc) error {\n\treturn r.walk(walkFn, []*Route{})\n}\n\n// SkipRouter is used as a return value from WalkFuncs to indicate that the\n// router that walk is about to descend down to should be skipped.\nvar SkipRouter = errors.New(\"skip this router\")\n\n// WalkFunc is the type of the function called for each route visited by Walk.\n// At every invocation, it is given the current route, and the current router,\n// and a list of ancestor routes that lead to the current route.\ntype WalkFunc func(route *Route, router *Router, ancestors []*Route) error\n\nfunc (r *Router) walk(walkFn WalkFunc, ancestors []*Route) error {\n\tfor _, t := range r.routes {\n\t\terr := walkFn(t, r, ancestors)\n\t\tif err == SkipRouter {\n\t\t\tcontinue\n\t\t}\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tfor _, sr := range t.matchers {\n\t\t\tif h, ok := sr.(*Router); ok {\n\t\t\t\tancestors = append(ancestors, t)\n\t\t\t\terr := h.walk(walkFn, ancestors)\n\t\t\t\tif err != nil {\n\t\t\t\t\treturn err\n\t\t\t\t}\n\t\t\t\tancestors = ancestors[:len(ancestors)-1]\n\t\t\t}\n\t\t}\n\t\tif h, ok := t.handler.(*Router); ok {\n\t\t\tancestors = append(ancestors, t)\n\t\t\terr := h.walk(walkFn, ancestors)\n\t\t\tif err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t\tancestors = ancestors[:len(ancestors)-1]\n\t\t}\n\t}\n\treturn nil\n}\n\n// ----------------------------------------------------------------------------\n// Context\n// ----------------------------------------------------------------------------\n\n// RouteMatch stores information about a matched route.\ntype RouteMatch struct {\n\tRoute *Route\n\tHandler http.Handler\n\tVars map[string]string\n\n\t// MatchErr is set to appropriate matching error\n\t// It is set to ErrMethodMismatch if there is a mismatch in\n\t// the request method and route method\n\tMatchErr error\n}\n\ntype contextKey int\n\nconst (\n\tvarsKey contextKey = iota\n\trouteKey\n)\n\n// Vars returns the route variables for the current request, if any.\nfunc Vars(r *http.Request) map[string]string {\n\tif rv := r.Context().Value(varsKey); rv != nil {\n\t\treturn rv.(map[string]string)\n\t}\n\treturn nil\n}\n\n// CurrentRoute returns the matched route for the current request, if any.\n// This only works when called inside the handler of the matched route\n// because the matched route is stored in the request context which is cleared\n// after the handler returns.\nfunc CurrentRoute(r *http.Request) *Route {\n\tif rv := r.Context().Value(routeKey); rv != nil {\n\t\treturn rv.(*Route)\n\t}\n\treturn nil\n}\n\nfunc requestWithVars(r *http.Request, vars map[string]string) *http.Request {\n\tctx := context.WithValue(r.Context(), varsKey, vars)\n\treturn r.WithContext(ctx)\n}\n\nfunc requestWithRoute(r *http.Request, route *Route) *http.Request {\n\tctx := context.WithValue(r.Context(), routeKey, route)\n\treturn r.WithContext(ctx)\n}\n\n// ----------------------------------------------------------------------------\n// Helpers\n// ----------------------------------------------------------------------------\n\n// cleanPath returns the canonical path for p, eliminating . and .. elements.\n// Borrowed from the net/http package.\nfunc cleanPath(p string) string {\n\tif p == \"\" {\n\t\treturn \"/\"\n\t}\n\tif p[0] != '/' {\n\t\tp = \"/\" + p\n\t}\n\tnp := path.Clean(p)\n\t// path.Clean removes trailing slash except for root;\n\t// put the trailing slash back if necessary.\n\tif p[len(p)-1] == '/' && np != \"/\" {\n\t\tnp += \"/\"\n\t}\n\n\treturn np\n}\n\n// uniqueVars returns an error if two slices contain duplicated strings.\nfunc uniqueVars(s1, s2 []string) error {\n\tfor _, v1 := range s1 {\n\t\tfor _, v2 := range s2 {\n\t\t\tif v1 == v2 {\n\t\t\t\treturn fmt.Errorf(\"mux: duplicated route variable %q\", v2)\n\t\t\t}\n\t\t}\n\t}\n\treturn nil\n}\n\n// checkPairs returns the count of strings passed in, and an error if\n// the count is not an even number.\nfunc checkPairs(pairs ...string) (int, error) {\n\tlength := len(pairs)\n\tif length%2 != 0 {\n\t\treturn length, fmt.Errorf(\n\t\t\t\"mux: number of parameters must be multiple of 2, got %v\", pairs)\n\t}\n\treturn length, nil\n}\n\n// mapFromPairsToString converts variadic string parameters to a\n// string to string map.\nfunc mapFromPairsToString(pairs ...string) (map[string]string, error) {\n\tlength, err := checkPairs(pairs...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tm := make(map[string]string, length/2)\n\tfor i := 0; i < length; i += 2 {\n\t\tm[pairs[i]] = pairs[i+1]\n\t}\n\treturn m, nil\n}\n\n// mapFromPairsToRegex converts variadic string parameters to a\n// string to regex map.\nfunc mapFromPairsToRegex(pairs ...string) (map[string]*regexp.Regexp, error) {\n\tlength, err := checkPairs(pairs...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tm := make(map[string]*regexp.Regexp, length/2)\n\tfor i := 0; i < length; i += 2 {\n\t\tregex, err := regexp.Compile(pairs[i+1])\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tm[pairs[i]] = regex\n\t}\n\treturn m, nil\n}\n\n// matchInArray returns true if the given string value is in the array.\nfunc matchInArray(arr []string, value string) bool {\n\tfor _, v := range arr {\n\t\tif v == value {\n\t\t\treturn true\n\t\t}\n\t}\n\treturn false\n}\n\n// matchMapWithString returns true if the given key/value pairs exist in a given map.\nfunc matchMapWithString(toCheck map[string]string, toMatch map[string][]string, canonicalKey bool) bool {\n\tfor k, v := range toCheck {\n\t\t// Check if key exists.\n\t\tif canonicalKey {\n\t\t\tk = http.CanonicalHeaderKey(k)\n\t\t}\n\t\tif values := toMatch[k]; values == nil {\n\t\t\treturn false\n\t\t} else if v != \"\" {\n\t\t\t// If value was defined as an empty string we only check that the\n\t\t\t// key exists. Otherwise we also check for equality.\n\t\t\tvalueExists := false\n\t\t\tfor _, value := range values {\n\t\t\t\tif v == value {\n\t\t\t\t\tvalueExists = true\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t\tif !valueExists {\n\t\t\t\treturn false\n\t\t\t}\n\t\t}\n\t}\n\treturn true\n}\n\n// matchMapWithRegex returns true if the given key/value pairs exist in a given map compiled against\n// the given regex\nfunc matchMapWithRegex(toCheck map[string]*regexp.Regexp, toMatch map[string][]string, canonicalKey bool) bool {\n\tfor k, v := range toCheck {\n\t\t// Check if key exists.\n\t\tif canonicalKey {\n\t\t\tk = http.CanonicalHeaderKey(k)\n\t\t}\n\t\tif values := toMatch[k]; values == nil {\n\t\t\treturn false\n\t\t} else if v != nil {\n\t\t\t// If value was defined as an empty string we only check that the\n\t\t\t// key exists. Otherwise we also check for equality.\n\t\t\tvalueExists := false\n\t\t\tfor _, value := range values {\n\t\t\t\tif v.MatchString(value) {\n\t\t\t\t\tvalueExists = true\n\t\t\t\t\tbreak\n\t\t\t\t}\n\t\t\t}\n\t\t\tif !valueExists {\n\t\t\t\treturn false\n\t\t\t}\n\t\t}\n\t}\n\treturn true\n}\n\n// methodNotAllowed replies to the request with an HTTP status code 405.\nfunc methodNotAllowed(w http.ResponseWriter, r *http.Request) {\n\tw.WriteHeader(http.StatusMethodNotAllowed)\n}\n\n// methodNotAllowedHandler returns a simple request handler\n// that replies to each request with a status code 405.\nfunc methodNotAllowedHandler() http.Handler { return http.HandlerFunc(methodNotAllowed) }\n"
},
{
"path": "vendor/github.com/gorilla/mux/regexp.go",
"content": "// Copyright 2012 The Gorilla Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage mux\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"net/url\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n)\n\ntype routeRegexpOptions struct {\n\tstrictSlash bool\n\tuseEncodedPath bool\n}\n\ntype regexpType int\n\nconst (\n\tregexpTypePath regexpType = iota\n\tregexpTypeHost\n\tregexpTypePrefix\n\tregexpTypeQuery\n)\n\n// newRouteRegexp parses a route template and returns a routeRegexp,\n// used to match a host, a path or a query string.\n//\n// It will extract named variables, assemble a regexp to be matched, create\n// a \"reverse\" template to build URLs and compile regexps to validate variable\n// values used in URL building.\n//\n// Previously we accepted only Python-like identifiers for variable\n// names ([a-zA-Z_][a-zA-Z0-9_]*), but currently the only restriction is that\n// name and pattern can't be empty, and names can't contain a colon.\nfunc newRouteRegexp(tpl string, typ regexpType, options routeRegexpOptions) (*routeRegexp, error) {\n\t// Check if it is well-formed.\n\tidxs, errBraces := braceIndices(tpl)\n\tif errBraces != nil {\n\t\treturn nil, errBraces\n\t}\n\t// Backup the original.\n\ttemplate := tpl\n\t// Now let's parse it.\n\tdefaultPattern := \"[^/]+\"\n\tif typ == regexpTypeQuery {\n\t\tdefaultPattern = \".*\"\n\t} else if typ == regexpTypeHost {\n\t\tdefaultPattern = \"[^.]+\"\n\t}\n\t// Only match strict slash if not matching\n\tif typ != regexpTypePath {\n\t\toptions.strictSlash = false\n\t}\n\t// Set a flag for strictSlash.\n\tendSlash := false\n\tif options.strictSlash && strings.HasSuffix(tpl, \"/\") {\n\t\ttpl = tpl[:len(tpl)-1]\n\t\tendSlash = true\n\t}\n\tvarsN := make([]string, len(idxs)/2)\n\tvarsR := make([]*regexp.Regexp, len(idxs)/2)\n\tpattern := bytes.NewBufferString(\"\")\n\tpattern.WriteByte('^')\n\treverse := bytes.NewBufferString(\"\")\n\tvar end int\n\tvar err error\n\tfor i := 0; i < len(idxs); i += 2 {\n\t\t// Set all values we are interested in.\n\t\traw := tpl[end:idxs[i]]\n\t\tend = idxs[i+1]\n\t\tparts := strings.SplitN(tpl[idxs[i]+1:end-1], \":\", 2)\n\t\tname := parts[0]\n\t\tpatt := defaultPattern\n\t\tif len(parts) == 2 {\n\t\t\tpatt = parts[1]\n\t\t}\n\t\t// Name or pattern can't be empty.\n\t\tif name == \"\" || patt == \"\" {\n\t\t\treturn nil, fmt.Errorf(\"mux: missing name or pattern in %q\",\n\t\t\t\ttpl[idxs[i]:end])\n\t\t}\n\t\t// Build the regexp pattern.\n\t\tfmt.Fprintf(pattern, \"%s(?P<%s>%s)\", regexp.QuoteMeta(raw), varGroupName(i/2), patt)\n\n\t\t// Build the reverse template.\n\t\tfmt.Fprintf(reverse, \"%s%%s\", raw)\n\n\t\t// Append variable name and compiled pattern.\n\t\tvarsN[i/2] = name\n\t\tvarsR[i/2], err = regexp.Compile(fmt.Sprintf(\"^%s$\", patt))\n\t\tif err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\t// Add the remaining.\n\traw := tpl[end:]\n\tpattern.WriteString(regexp.QuoteMeta(raw))\n\tif options.strictSlash {\n\t\tpattern.WriteString(\"[/]?\")\n\t}\n\tif typ == regexpTypeQuery {\n\t\t// Add the default pattern if the query value is empty\n\t\tif queryVal := strings.SplitN(template, \"=\", 2)[1]; queryVal == \"\" {\n\t\t\tpattern.WriteString(defaultPattern)\n\t\t}\n\t}\n\tif typ != regexpTypePrefix {\n\t\tpattern.WriteByte('$')\n\t}\n\n\tvar wildcardHostPort bool\n\tif typ == regexpTypeHost {\n\t\tif !strings.Contains(pattern.String(), \":\") {\n\t\t\twildcardHostPort = true\n\t\t}\n\t}\n\treverse.WriteString(raw)\n\tif endSlash {\n\t\treverse.WriteByte('/')\n\t}\n\t// Compile full regexp.\n\treg, errCompile := regexp.Compile(pattern.String())\n\tif errCompile != nil {\n\t\treturn nil, errCompile\n\t}\n\n\t// Check for capturing groups which used to work in older versions\n\tif reg.NumSubexp() != len(idxs)/2 {\n\t\tpanic(fmt.Sprintf(\"route %s contains capture groups in its regexp. \", template) +\n\t\t\t\"Only non-capturing groups are accepted: e.g. (?:pattern) instead of (pattern)\")\n\t}\n\n\t// Done!\n\treturn &routeRegexp{\n\t\ttemplate: template,\n\t\tregexpType: typ,\n\t\toptions: options,\n\t\tregexp: reg,\n\t\treverse: reverse.String(),\n\t\tvarsN: varsN,\n\t\tvarsR: varsR,\n\t\twildcardHostPort: wildcardHostPort,\n\t}, nil\n}\n\n// routeRegexp stores a regexp to match a host or path and information to\n// collect and validate route variables.\ntype routeRegexp struct {\n\t// The unmodified template.\n\ttemplate string\n\t// The type of match\n\tregexpType regexpType\n\t// Options for matching\n\toptions routeRegexpOptions\n\t// Expanded regexp.\n\tregexp *regexp.Regexp\n\t// Reverse template.\n\treverse string\n\t// Variable names.\n\tvarsN []string\n\t// Variable regexps (validators).\n\tvarsR []*regexp.Regexp\n\t// Wildcard host-port (no strict port match in hostname)\n\twildcardHostPort bool\n}\n\n// Match matches the regexp against the URL host or path.\nfunc (r *routeRegexp) Match(req *http.Request, match *RouteMatch) bool {\n\tif r.regexpType == regexpTypeHost {\n\t\thost := getHost(req)\n\t\tif r.wildcardHostPort {\n\t\t\t// Don't be strict on the port match\n\t\t\tif i := strings.Index(host, \":\"); i != -1 {\n\t\t\t\thost = host[:i]\n\t\t\t}\n\t\t}\n\t\treturn r.regexp.MatchString(host)\n\t}\n\n\tif r.regexpType == regexpTypeQuery {\n\t\treturn r.matchQueryString(req)\n\t}\n\tpath := req.URL.Path\n\tif r.options.useEncodedPath {\n\t\tpath = req.URL.EscapedPath()\n\t}\n\treturn r.regexp.MatchString(path)\n}\n\n// url builds a URL part using the given values.\nfunc (r *routeRegexp) url(values map[string]string) (string, error) {\n\turlValues := make([]interface{}, len(r.varsN))\n\tfor k, v := range r.varsN {\n\t\tvalue, ok := values[v]\n\t\tif !ok {\n\t\t\treturn \"\", fmt.Errorf(\"mux: missing route variable %q\", v)\n\t\t}\n\t\tif r.regexpType == regexpTypeQuery {\n\t\t\tvalue = url.QueryEscape(value)\n\t\t}\n\t\turlValues[k] = value\n\t}\n\trv := fmt.Sprintf(r.reverse, urlValues...)\n\tif !r.regexp.MatchString(rv) {\n\t\t// The URL is checked against the full regexp, instead of checking\n\t\t// individual variables. This is faster but to provide a good error\n\t\t// message, we check individual regexps if the URL doesn't match.\n\t\tfor k, v := range r.varsN {\n\t\t\tif !r.varsR[k].MatchString(values[v]) {\n\t\t\t\treturn \"\", fmt.Errorf(\n\t\t\t\t\t\"mux: variable %q doesn't match, expected %q\", values[v],\n\t\t\t\t\tr.varsR[k].String())\n\t\t\t}\n\t\t}\n\t}\n\treturn rv, nil\n}\n\n// getURLQuery returns a single query parameter from a request URL.\n// For a URL with foo=bar&baz=ding, we return only the relevant key\n// value pair for the routeRegexp.\nfunc (r *routeRegexp) getURLQuery(req *http.Request) string {\n\tif r.regexpType != regexpTypeQuery {\n\t\treturn \"\"\n\t}\n\ttemplateKey := strings.SplitN(r.template, \"=\", 2)[0]\n\tval, ok := findFirstQueryKey(req.URL.RawQuery, templateKey)\n\tif ok {\n\t\treturn templateKey + \"=\" + val\n\t}\n\treturn \"\"\n}\n\n// findFirstQueryKey returns the same result as (*url.URL).Query()[key][0].\n// If key was not found, empty string and false is returned.\nfunc findFirstQueryKey(rawQuery, key string) (value string, ok bool) {\n\tquery := []byte(rawQuery)\n\tfor len(query) > 0 {\n\t\tfoundKey := query\n\t\tif i := bytes.IndexAny(foundKey, \"&;\"); i >= 0 {\n\t\t\tfoundKey, query = foundKey[:i], foundKey[i+1:]\n\t\t} else {\n\t\t\tquery = query[:0]\n\t\t}\n\t\tif len(foundKey) == 0 {\n\t\t\tcontinue\n\t\t}\n\t\tvar value []byte\n\t\tif i := bytes.IndexByte(foundKey, '='); i >= 0 {\n\t\t\tfoundKey, value = foundKey[:i], foundKey[i+1:]\n\t\t}\n\t\tif len(foundKey) < len(key) {\n\t\t\t// Cannot possibly be key.\n\t\t\tcontinue\n\t\t}\n\t\tkeyString, err := url.QueryUnescape(string(foundKey))\n\t\tif err != nil {\n\t\t\tcontinue\n\t\t}\n\t\tif keyString != key {\n\t\t\tcontinue\n\t\t}\n\t\tvalueString, err := url.QueryUnescape(string(value))\n\t\tif err != nil {\n\t\t\tcontinue\n\t\t}\n\t\treturn valueString, true\n\t}\n\treturn \"\", false\n}\n\nfunc (r *routeRegexp) matchQueryString(req *http.Request) bool {\n\treturn r.regexp.MatchString(r.getURLQuery(req))\n}\n\n// braceIndices returns the first level curly brace indices from a string.\n// It returns an error in case of unbalanced braces.\nfunc braceIndices(s string) ([]int, error) {\n\tvar level, idx int\n\tvar idxs []int\n\tfor i := 0; i < len(s); i++ {\n\t\tswitch s[i] {\n\t\tcase '{':\n\t\t\tif level++; level == 1 {\n\t\t\t\tidx = i\n\t\t\t}\n\t\tcase '}':\n\t\t\tif level--; level == 0 {\n\t\t\t\tidxs = append(idxs, idx, i+1)\n\t\t\t} else if level < 0 {\n\t\t\t\treturn nil, fmt.Errorf(\"mux: unbalanced braces in %q\", s)\n\t\t\t}\n\t\t}\n\t}\n\tif level != 0 {\n\t\treturn nil, fmt.Errorf(\"mux: unbalanced braces in %q\", s)\n\t}\n\treturn idxs, nil\n}\n\n// varGroupName builds a capturing group name for the indexed variable.\nfunc varGroupName(idx int) string {\n\treturn \"v\" + strconv.Itoa(idx)\n}\n\n// ----------------------------------------------------------------------------\n// routeRegexpGroup\n// ----------------------------------------------------------------------------\n\n// routeRegexpGroup groups the route matchers that carry variables.\ntype routeRegexpGroup struct {\n\thost *routeRegexp\n\tpath *routeRegexp\n\tqueries []*routeRegexp\n}\n\n// setMatch extracts the variables from the URL once a route matches.\nfunc (v routeRegexpGroup) setMatch(req *http.Request, m *RouteMatch, r *Route) {\n\t// Store host variables.\n\tif v.host != nil {\n\t\thost := getHost(req)\n\t\tif v.host.wildcardHostPort {\n\t\t\t// Don't be strict on the port match\n\t\t\tif i := strings.Index(host, \":\"); i != -1 {\n\t\t\t\thost = host[:i]\n\t\t\t}\n\t\t}\n\t\tmatches := v.host.regexp.FindStringSubmatchIndex(host)\n\t\tif len(matches) > 0 {\n\t\t\textractVars(host, matches, v.host.varsN, m.Vars)\n\t\t}\n\t}\n\tpath := req.URL.Path\n\tif r.useEncodedPath {\n\t\tpath = req.URL.EscapedPath()\n\t}\n\t// Store path variables.\n\tif v.path != nil {\n\t\tmatches := v.path.regexp.FindStringSubmatchIndex(path)\n\t\tif len(matches) > 0 {\n\t\t\textractVars(path, matches, v.path.varsN, m.Vars)\n\t\t\t// Check if we should redirect.\n\t\t\tif v.path.options.strictSlash {\n\t\t\t\tp1 := strings.HasSuffix(path, \"/\")\n\t\t\t\tp2 := strings.HasSuffix(v.path.template, \"/\")\n\t\t\t\tif p1 != p2 {\n\t\t\t\t\tu, _ := url.Parse(req.URL.String())\n\t\t\t\t\tif p1 {\n\t\t\t\t\t\tu.Path = u.Path[:len(u.Path)-1]\n\t\t\t\t\t} else {\n\t\t\t\t\t\tu.Path += \"/\"\n\t\t\t\t\t}\n\t\t\t\t\tm.Handler = http.RedirectHandler(u.String(), http.StatusMovedPermanently)\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t// Store query string variables.\n\tfor _, q := range v.queries {\n\t\tqueryURL := q.getURLQuery(req)\n\t\tmatches := q.regexp.FindStringSubmatchIndex(queryURL)\n\t\tif len(matches) > 0 {\n\t\t\textractVars(queryURL, matches, q.varsN, m.Vars)\n\t\t}\n\t}\n}\n\n// getHost tries its best to return the request host.\n// According to section 14.23 of RFC 2616 the Host header\n// can include the port number if the default value of 80 is not used.\nfunc getHost(r *http.Request) string {\n\tif r.URL.IsAbs() {\n\t\treturn r.URL.Host\n\t}\n\treturn r.Host\n}\n\nfunc extractVars(input string, matches []int, names []string, output map[string]string) {\n\tfor i, name := range names {\n\t\toutput[name] = input[matches[2*i+2]:matches[2*i+3]]\n\t}\n}\n"
},
{
"path": "vendor/github.com/gorilla/mux/route.go",
"content": "// Copyright 2012 The Gorilla Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage mux\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n\t\"net/http\"\n\t\"net/url\"\n\t\"regexp\"\n\t\"strings\"\n)\n\n// Route stores information to match a request and build URLs.\ntype Route struct {\n\t// Request handler for the route.\n\thandler http.Handler\n\t// If true, this route never matches: it is only used to build URLs.\n\tbuildOnly bool\n\t// The name used to build URLs.\n\tname string\n\t// Error resulted from building a route.\n\terr error\n\n\t// \"global\" reference to all named routes\n\tnamedRoutes map[string]*Route\n\n\t// config possibly passed in from `Router`\n\trouteConf\n}\n\n// SkipClean reports whether path cleaning is enabled for this route via\n// Router.SkipClean.\nfunc (r *Route) SkipClean() bool {\n\treturn r.skipClean\n}\n\n// Match matches the route against the request.\nfunc (r *Route) Match(req *http.Request, match *RouteMatch) bool {\n\tif r.buildOnly || r.err != nil {\n\t\treturn false\n\t}\n\n\tvar matchErr error\n\n\t// Match everything.\n\tfor _, m := range r.matchers {\n\t\tif matched := m.Match(req, match); !matched {\n\t\t\tif _, ok := m.(methodMatcher); ok {\n\t\t\t\tmatchErr = ErrMethodMismatch\n\t\t\t\tcontinue\n\t\t\t}\n\n\t\t\t// Ignore ErrNotFound errors. These errors arise from match call\n\t\t\t// to Subrouters.\n\t\t\t//\n\t\t\t// This prevents subsequent matching subrouters from failing to\n\t\t\t// run middleware. If not ignored, the middleware would see a\n\t\t\t// non-nil MatchErr and be skipped, even when there was a\n\t\t\t// matching route.\n\t\t\tif match.MatchErr == ErrNotFound {\n\t\t\t\tmatch.MatchErr = nil\n\t\t\t}\n\n\t\t\tmatchErr = nil // nolint:ineffassign\n\t\t\treturn false\n\t\t} else {\n\t\t\t// Multiple routes may share the same path but use different HTTP methods. For instance:\n\t\t\t// Route 1: POST \"/users/{id}\".\n\t\t\t// Route 2: GET \"/users/{id}\", parameters: \"id\": \"[0-9]+\".\n\t\t\t//\n\t\t\t// The router must handle these cases correctly. For a GET request to \"/users/abc\" with \"id\" as \"-2\",\n\t\t\t// The router should return a \"Not Found\" error as no route fully matches this request.\n\t\t\tif match.MatchErr == ErrMethodMismatch {\n\t\t\t\tmatch.MatchErr = nil\n\t\t\t}\n\t\t}\n\t}\n\n\tif matchErr != nil {\n\t\tmatch.MatchErr = matchErr\n\t\treturn false\n\t}\n\n\tif match.MatchErr == ErrMethodMismatch && r.handler != nil {\n\t\t// We found a route which matches request method, clear MatchErr\n\t\tmatch.MatchErr = nil\n\t\t// Then override the mis-matched handler\n\t\tmatch.Handler = r.handler\n\t}\n\n\t// Yay, we have a match. Let's collect some info about it.\n\tif match.Route == nil {\n\t\tmatch.Route = r\n\t}\n\tif match.Handler == nil {\n\t\tmatch.Handler = r.handler\n\t}\n\tif match.Vars == nil {\n\t\tmatch.Vars = make(map[string]string)\n\t}\n\n\t// Set variables.\n\tr.regexp.setMatch(req, match, r)\n\treturn true\n}\n\n// ----------------------------------------------------------------------------\n// Route attributes\n// ----------------------------------------------------------------------------\n\n// GetError returns an error resulted from building the route, if any.\nfunc (r *Route) GetError() error {\n\treturn r.err\n}\n\n// BuildOnly sets the route to never match: it is only used to build URLs.\nfunc (r *Route) BuildOnly() *Route {\n\tr.buildOnly = true\n\treturn r\n}\n\n// Handler --------------------------------------------------------------------\n\n// Handler sets a handler for the route.\nfunc (r *Route) Handler(handler http.Handler) *Route {\n\tif r.err == nil {\n\t\tr.handler = handler\n\t}\n\treturn r\n}\n\n// HandlerFunc sets a handler function for the route.\nfunc (r *Route) HandlerFunc(f func(http.ResponseWriter, *http.Request)) *Route {\n\treturn r.Handler(http.HandlerFunc(f))\n}\n\n// GetHandler returns the handler for the route, if any.\nfunc (r *Route) GetHandler() http.Handler {\n\treturn r.handler\n}\n\n// Name -----------------------------------------------------------------------\n\n// Name sets the name for the route, used to build URLs.\n// It is an error to call Name more than once on a route.\nfunc (r *Route) Name(name string) *Route {\n\tif r.name != \"\" {\n\t\tr.err = fmt.Errorf(\"mux: route already has name %q, can't set %q\",\n\t\t\tr.name, name)\n\t}\n\tif r.err == nil {\n\t\tr.name = name\n\t\tr.namedRoutes[name] = r\n\t}\n\treturn r\n}\n\n// GetName returns the name for the route, if any.\nfunc (r *Route) GetName() string {\n\treturn r.name\n}\n\n// ----------------------------------------------------------------------------\n// Matchers\n// ----------------------------------------------------------------------------\n\n// matcher types try to match a request.\ntype matcher interface {\n\tMatch(*http.Request, *RouteMatch) bool\n}\n\n// addMatcher adds a matcher to the route.\nfunc (r *Route) addMatcher(m matcher) *Route {\n\tif r.err == nil {\n\t\tr.matchers = append(r.matchers, m)\n\t}\n\treturn r\n}\n\n// addRegexpMatcher adds a host or path matcher and builder to a route.\nfunc (r *Route) addRegexpMatcher(tpl string, typ regexpType) error {\n\tif r.err != nil {\n\t\treturn r.err\n\t}\n\tif typ == regexpTypePath || typ == regexpTypePrefix {\n\t\tif len(tpl) > 0 && tpl[0] != '/' {\n\t\t\treturn fmt.Errorf(\"mux: path must start with a slash, got %q\", tpl)\n\t\t}\n\t\tif r.regexp.path != nil {\n\t\t\ttpl = strings.TrimRight(r.regexp.path.template, \"/\") + tpl\n\t\t}\n\t}\n\trr, err := newRouteRegexp(tpl, typ, routeRegexpOptions{\n\t\tstrictSlash: r.strictSlash,\n\t\tuseEncodedPath: r.useEncodedPath,\n\t})\n\tif err != nil {\n\t\treturn err\n\t}\n\tfor _, q := range r.regexp.queries {\n\t\tif err = uniqueVars(rr.varsN, q.varsN); err != nil {\n\t\t\treturn err\n\t\t}\n\t}\n\tif typ == regexpTypeHost {\n\t\tif r.regexp.path != nil {\n\t\t\tif err = uniqueVars(rr.varsN, r.regexp.path.varsN); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\tr.regexp.host = rr\n\t} else {\n\t\tif r.regexp.host != nil {\n\t\t\tif err = uniqueVars(rr.varsN, r.regexp.host.varsN); err != nil {\n\t\t\t\treturn err\n\t\t\t}\n\t\t}\n\t\tif typ == regexpTypeQuery {\n\t\t\tr.regexp.queries = append(r.regexp.queries, rr)\n\t\t} else {\n\t\t\tr.regexp.path = rr\n\t\t}\n\t}\n\tr.addMatcher(rr)\n\treturn nil\n}\n\n// Headers --------------------------------------------------------------------\n\n// headerMatcher matches the request against header values.\ntype headerMatcher map[string]string\n\nfunc (m headerMatcher) Match(r *http.Request, match *RouteMatch) bool {\n\treturn matchMapWithString(m, r.Header, true)\n}\n\n// Headers adds a matcher for request header values.\n// It accepts a sequence of key/value pairs to be matched. For example:\n//\n//\tr := mux.NewRouter().NewRoute()\n//\tr.Headers(\"Content-Type\", \"application/json\",\n//\t \"X-Requested-With\", \"XMLHttpRequest\")\n//\n// The above route will only match if both request header values match.\n// If the value is an empty string, it will match any value if the key is set.\nfunc (r *Route) Headers(pairs ...string) *Route {\n\tif r.err == nil {\n\t\tvar headers map[string]string\n\t\theaders, r.err = mapFromPairsToString(pairs...)\n\t\treturn r.addMatcher(headerMatcher(headers))\n\t}\n\treturn r\n}\n\n// headerRegexMatcher matches the request against the route given a regex for the header\ntype headerRegexMatcher map[string]*regexp.Regexp\n\nfunc (m headerRegexMatcher) Match(r *http.Request, match *RouteMatch) bool {\n\treturn matchMapWithRegex(m, r.Header, true)\n}\n\n// HeadersRegexp accepts a sequence of key/value pairs, where the value has regex\n// support. For example:\n//\n//\tr := mux.NewRouter().NewRoute()\n//\tr.HeadersRegexp(\"Content-Type\", \"application/(text|json)\",\n//\t \"X-Requested-With\", \"XMLHttpRequest\")\n//\n// The above route will only match if both the request header matches both regular expressions.\n// If the value is an empty string, it will match any value if the key is set.\n// Use the start and end of string anchors (^ and $) to match an exact value.\nfunc (r *Route) HeadersRegexp(pairs ...string) *Route {\n\tif r.err == nil {\n\t\tvar headers map[string]*regexp.Regexp\n\t\theaders, r.err = mapFromPairsToRegex(pairs...)\n\t\treturn r.addMatcher(headerRegexMatcher(headers))\n\t}\n\treturn r\n}\n\n// Host -----------------------------------------------------------------------\n\n// Host adds a matcher for the URL host.\n// It accepts a template with zero or more URL variables enclosed by {}.\n// Variables can define an optional regexp pattern to be matched:\n//\n// - {name} matches anything until the next dot.\n//\n// - {name:pattern} matches the given regexp pattern.\n//\n// For example:\n//\n//\tr := mux.NewRouter().NewRoute()\n//\tr.Host(\"www.example.com\")\n//\tr.Host(\"{subdomain}.domain.com\")\n//\tr.Host(\"{subdomain:[a-z]+}.domain.com\")\n//\n// Variable names must be unique in a given route. They can be retrieved\n// calling mux.Vars(request).\nfunc (r *Route) Host(tpl string) *Route {\n\tr.err = r.addRegexpMatcher(tpl, regexpTypeHost)\n\treturn r\n}\n\n// MatcherFunc ----------------------------------------------------------------\n\n// MatcherFunc is the function signature used by custom matchers.\ntype MatcherFunc func(*http.Request, *RouteMatch) bool\n\n// Match returns the match for a given request.\nfunc (m MatcherFunc) Match(r *http.Request, match *RouteMatch) bool {\n\treturn m(r, match)\n}\n\n// MatcherFunc adds a custom function to be used as request matcher.\nfunc (r *Route) MatcherFunc(f MatcherFunc) *Route {\n\treturn r.addMatcher(f)\n}\n\n// Methods --------------------------------------------------------------------\n\n// methodMatcher matches the request against HTTP methods.\ntype methodMatcher []string\n\nfunc (m methodMatcher) Match(r *http.Request, match *RouteMatch) bool {\n\treturn matchInArray(m, r.Method)\n}\n\n// Methods adds a matcher for HTTP methods.\n// It accepts a sequence of one or more methods to be matched, e.g.:\n// \"GET\", \"POST\", \"PUT\".\nfunc (r *Route) Methods(methods ...string) *Route {\n\tfor k, v := range methods {\n\t\tmethods[k] = strings.ToUpper(v)\n\t}\n\treturn r.addMatcher(methodMatcher(methods))\n}\n\n// Path -----------------------------------------------------------------------\n\n// Path adds a matcher for the URL path.\n// It accepts a template with zero or more URL variables enclosed by {}. The\n// template must start with a \"/\".\n// Variables can define an optional regexp pattern to be matched:\n//\n// - {name} matches anything until the next slash.\n//\n// - {name:pattern} matches the given regexp pattern.\n//\n// For example:\n//\n//\tr := mux.NewRouter().NewRoute()\n//\tr.Path(\"/products/\").Handler(ProductsHandler)\n//\tr.Path(\"/products/{key}\").Handler(ProductsHandler)\n//\tr.Path(\"/articles/{category}/{id:[0-9]+}\").\n//\t Handler(ArticleHandler)\n//\n// Variable names must be unique in a given route. They can be retrieved\n// calling mux.Vars(request).\nfunc (r *Route) Path(tpl string) *Route {\n\tr.err = r.addRegexpMatcher(tpl, regexpTypePath)\n\treturn r\n}\n\n// PathPrefix -----------------------------------------------------------------\n\n// PathPrefix adds a matcher for the URL path prefix. This matches if the given\n// template is a prefix of the full URL path. See Route.Path() for details on\n// the tpl argument.\n//\n// Note that it does not treat slashes specially (\"/foobar/\" will be matched by\n// the prefix \"/foo\") so you may want to use a trailing slash here.\n//\n// Also note that the setting of Router.StrictSlash() has no effect on routes\n// with a PathPrefix matcher.\nfunc (r *Route) PathPrefix(tpl string) *Route {\n\tr.err = r.addRegexpMatcher(tpl, regexpTypePrefix)\n\treturn r\n}\n\n// Query ----------------------------------------------------------------------\n\n// Queries adds a matcher for URL query values.\n// It accepts a sequence of key/value pairs. Values may define variables.\n// For example:\n//\n//\tr := mux.NewRouter().NewRoute()\n//\tr.Queries(\"foo\", \"bar\", \"id\", \"{id:[0-9]+}\")\n//\n// The above route will only match if the URL contains the defined queries\n// values, e.g.: ?foo=bar&id=42.\n//\n// If the value is an empty string, it will match any value if the key is set.\n//\n// Variables can define an optional regexp pattern to be matched:\n//\n// - {name} matches anything until the next slash.\n//\n// - {name:pattern} matches the given regexp pattern.\nfunc (r *Route) Queries(pairs ...string) *Route {\n\tlength := len(pairs)\n\tif length%2 != 0 {\n\t\tr.err = fmt.Errorf(\n\t\t\t\"mux: number of parameters must be multiple of 2, got %v\", pairs)\n\t\treturn nil\n\t}\n\tfor i := 0; i < length; i += 2 {\n\t\tif r.err = r.addRegexpMatcher(pairs[i]+\"=\"+pairs[i+1], regexpTypeQuery); r.err != nil {\n\t\t\treturn r\n\t\t}\n\t}\n\n\treturn r\n}\n\n// Schemes --------------------------------------------------------------------\n\n// schemeMatcher matches the request against URL schemes.\ntype schemeMatcher []string\n\nfunc (m schemeMatcher) Match(r *http.Request, match *RouteMatch) bool {\n\tscheme := r.URL.Scheme\n\t// https://golang.org/pkg/net/http/#Request\n\t// \"For [most] server requests, fields other than Path and RawQuery will be\n\t// empty.\"\n\t// Since we're an http muxer, the scheme is either going to be http or https\n\t// though, so we can just set it based on the tls termination state.\n\tif scheme == \"\" {\n\t\tif r.TLS == nil {\n\t\t\tscheme = \"http\"\n\t\t} else {\n\t\t\tscheme = \"https\"\n\t\t}\n\t}\n\treturn matchInArray(m, scheme)\n}\n\n// Schemes adds a matcher for URL schemes.\n// It accepts a sequence of schemes to be matched, e.g.: \"http\", \"https\".\n// If the request's URL has a scheme set, it will be matched against.\n// Generally, the URL scheme will only be set if a previous handler set it,\n// such as the ProxyHeaders handler from gorilla/handlers.\n// If unset, the scheme will be determined based on the request's TLS\n// termination state.\n// The first argument to Schemes will be used when constructing a route URL.\nfunc (r *Route) Schemes(schemes ...string) *Route {\n\tfor k, v := range schemes {\n\t\tschemes[k] = strings.ToLower(v)\n\t}\n\tif len(schemes) > 0 {\n\t\tr.buildScheme = schemes[0]\n\t}\n\treturn r.addMatcher(schemeMatcher(schemes))\n}\n\n// BuildVarsFunc --------------------------------------------------------------\n\n// BuildVarsFunc is the function signature used by custom build variable\n// functions (which can modify route variables before a route's URL is built).\ntype BuildVarsFunc func(map[string]string) map[string]string\n\n// BuildVarsFunc adds a custom function to be used to modify build variables\n// before a route's URL is built.\nfunc (r *Route) BuildVarsFunc(f BuildVarsFunc) *Route {\n\tif r.buildVarsFunc != nil {\n\t\t// compose the old and new functions\n\t\told := r.buildVarsFunc\n\t\tr.buildVarsFunc = func(m map[string]string) map[string]string {\n\t\t\treturn f(old(m))\n\t\t}\n\t} else {\n\t\tr.buildVarsFunc = f\n\t}\n\treturn r\n}\n\n// Subrouter ------------------------------------------------------------------\n\n// Subrouter creates a subrouter for the route.\n//\n// It will test the inner routes only if the parent route matched. For example:\n//\n//\tr := mux.NewRouter().NewRoute()\n//\ts := r.Host(\"www.example.com\").Subrouter()\n//\ts.HandleFunc(\"/products/\", ProductsHandler)\n//\ts.HandleFunc(\"/products/{key}\", ProductHandler)\n//\ts.HandleFunc(\"/articles/{category}/{id:[0-9]+}\"), ArticleHandler)\n//\n// Here, the routes registered in the subrouter won't be tested if the host\n// doesn't match.\nfunc (r *Route) Subrouter() *Router {\n\t// initialize a subrouter with a copy of the parent route's configuration\n\trouter := &Router{routeConf: copyRouteConf(r.routeConf), namedRoutes: r.namedRoutes}\n\tr.addMatcher(router)\n\treturn router\n}\n\n// ----------------------------------------------------------------------------\n// URL building\n// ----------------------------------------------------------------------------\n\n// URL builds a URL for the route.\n//\n// It accepts a sequence of key/value pairs for the route variables. For\n// example, given this route:\n//\n//\tr := mux.NewRouter()\n//\tr.HandleFunc(\"/articles/{category}/{id:[0-9]+}\", ArticleHandler).\n//\t Name(\"article\")\n//\n// ...a URL for it can be built using:\n//\n//\turl, err := r.Get(\"article\").URL(\"category\", \"technology\", \"id\", \"42\")\n//\n// ...which will return an url.URL with the following path:\n//\n//\t\"/articles/technology/42\"\n//\n// This also works for host variables:\n//\n//\tr := mux.NewRouter()\n//\tr.HandleFunc(\"/articles/{category}/{id:[0-9]+}\", ArticleHandler).\n//\t Host(\"{subdomain}.domain.com\").\n//\t Name(\"article\")\n//\n//\t// url.String() will be \"http://news.domain.com/articles/technology/42\"\n//\turl, err := r.Get(\"article\").URL(\"subdomain\", \"news\",\n//\t \"category\", \"technology\",\n//\t \"id\", \"42\")\n//\n// The scheme of the resulting url will be the first argument that was passed to Schemes:\n//\n//\t// url.String() will be \"https://example.com\"\n//\tr := mux.NewRouter().NewRoute()\n//\turl, err := r.Host(\"example.com\")\n//\t .Schemes(\"https\", \"http\").URL()\n//\n// All variables defined in the route are required, and their values must\n// conform to the corresponding patterns.\nfunc (r *Route) URL(pairs ...string) (*url.URL, error) {\n\tif r.err != nil {\n\t\treturn nil, r.err\n\t}\n\tvalues, err := r.prepareVars(pairs...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tvar scheme, host, path string\n\tqueries := make([]string, 0, len(r.regexp.queries))\n\tif r.regexp.host != nil {\n\t\tif host, err = r.regexp.host.url(values); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tscheme = \"http\"\n\t\tif r.buildScheme != \"\" {\n\t\t\tscheme = r.buildScheme\n\t\t}\n\t}\n\tif r.regexp.path != nil {\n\t\tif path, err = r.regexp.path.url(values); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t}\n\tfor _, q := range r.regexp.queries {\n\t\tvar query string\n\t\tif query, err = q.url(values); err != nil {\n\t\t\treturn nil, err\n\t\t}\n\t\tqueries = append(queries, query)\n\t}\n\treturn &url.URL{\n\t\tScheme: scheme,\n\t\tHost: host,\n\t\tPath: path,\n\t\tRawQuery: strings.Join(queries, \"&\"),\n\t}, nil\n}\n\n// URLHost builds the host part of the URL for a route. See Route.URL().\n//\n// The route must have a host defined.\nfunc (r *Route) URLHost(pairs ...string) (*url.URL, error) {\n\tif r.err != nil {\n\t\treturn nil, r.err\n\t}\n\tif r.regexp.host == nil {\n\t\treturn nil, errors.New(\"mux: route doesn't have a host\")\n\t}\n\tvalues, err := r.prepareVars(pairs...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\thost, err := r.regexp.host.url(values)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tu := &url.URL{\n\t\tScheme: \"http\",\n\t\tHost: host,\n\t}\n\tif r.buildScheme != \"\" {\n\t\tu.Scheme = r.buildScheme\n\t}\n\treturn u, nil\n}\n\n// URLPath builds the path part of the URL for a route. See Route.URL().\n//\n// The route must have a path defined.\nfunc (r *Route) URLPath(pairs ...string) (*url.URL, error) {\n\tif r.err != nil {\n\t\treturn nil, r.err\n\t}\n\tif r.regexp.path == nil {\n\t\treturn nil, errors.New(\"mux: route doesn't have a path\")\n\t}\n\tvalues, err := r.prepareVars(pairs...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\tpath, err := r.regexp.path.url(values)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn &url.URL{\n\t\tPath: path,\n\t}, nil\n}\n\n// GetPathTemplate returns the template used to build the\n// route match.\n// This is useful for building simple REST API documentation and for instrumentation\n// against third-party services.\n// An error will be returned if the route does not define a path.\nfunc (r *Route) GetPathTemplate() (string, error) {\n\tif r.err != nil {\n\t\treturn \"\", r.err\n\t}\n\tif r.regexp.path == nil {\n\t\treturn \"\", errors.New(\"mux: route doesn't have a path\")\n\t}\n\treturn r.regexp.path.template, nil\n}\n\n// GetPathRegexp returns the expanded regular expression used to match route path.\n// This is useful for building simple REST API documentation and for instrumentation\n// against third-party services.\n// An error will be returned if the route does not define a path.\nfunc (r *Route) GetPathRegexp() (string, error) {\n\tif r.err != nil {\n\t\treturn \"\", r.err\n\t}\n\tif r.regexp.path == nil {\n\t\treturn \"\", errors.New(\"mux: route does not have a path\")\n\t}\n\treturn r.regexp.path.regexp.String(), nil\n}\n\n// GetQueriesRegexp returns the expanded regular expressions used to match the\n// route queries.\n// This is useful for building simple REST API documentation and for instrumentation\n// against third-party services.\n// An error will be returned if the route does not have queries.\nfunc (r *Route) GetQueriesRegexp() ([]string, error) {\n\tif r.err != nil {\n\t\treturn nil, r.err\n\t}\n\tif r.regexp.queries == nil {\n\t\treturn nil, errors.New(\"mux: route doesn't have queries\")\n\t}\n\tqueries := make([]string, 0, len(r.regexp.queries))\n\tfor _, query := range r.regexp.queries {\n\t\tqueries = append(queries, query.regexp.String())\n\t}\n\treturn queries, nil\n}\n\n// GetQueriesTemplates returns the templates used to build the\n// query matching.\n// This is useful for building simple REST API documentation and for instrumentation\n// against third-party services.\n// An error will be returned if the route does not define queries.\nfunc (r *Route) GetQueriesTemplates() ([]string, error) {\n\tif r.err != nil {\n\t\treturn nil, r.err\n\t}\n\tif r.regexp.queries == nil {\n\t\treturn nil, errors.New(\"mux: route doesn't have queries\")\n\t}\n\tqueries := make([]string, 0, len(r.regexp.queries))\n\tfor _, query := range r.regexp.queries {\n\t\tqueries = append(queries, query.template)\n\t}\n\treturn queries, nil\n}\n\n// GetMethods returns the methods the route matches against\n// This is useful for building simple REST API documentation and for instrumentation\n// against third-party services.\n// An error will be returned if route does not have methods.\nfunc (r *Route) GetMethods() ([]string, error) {\n\tif r.err != nil {\n\t\treturn nil, r.err\n\t}\n\tfor _, m := range r.matchers {\n\t\tif methods, ok := m.(methodMatcher); ok {\n\t\t\treturn []string(methods), nil\n\t\t}\n\t}\n\treturn nil, errors.New(\"mux: route doesn't have methods\")\n}\n\n// GetHostTemplate returns the template used to build the\n// route match.\n// This is useful for building simple REST API documentation and for instrumentation\n// against third-party services.\n// An error will be returned if the route does not define a host.\nfunc (r *Route) GetHostTemplate() (string, error) {\n\tif r.err != nil {\n\t\treturn \"\", r.err\n\t}\n\tif r.regexp.host == nil {\n\t\treturn \"\", errors.New(\"mux: route doesn't have a host\")\n\t}\n\treturn r.regexp.host.template, nil\n}\n\n// GetVarNames returns the names of all variables added by regexp matchers\n// These can be used to know which route variables should be passed into r.URL()\nfunc (r *Route) GetVarNames() ([]string, error) {\n\tif r.err != nil {\n\t\treturn nil, r.err\n\t}\n\tvar varNames []string\n\tif r.regexp.host != nil {\n\t\tvarNames = append(varNames, r.regexp.host.varsN...)\n\t}\n\tif r.regexp.path != nil {\n\t\tvarNames = append(varNames, r.regexp.path.varsN...)\n\t}\n\tfor _, regx := range r.regexp.queries {\n\t\tvarNames = append(varNames, regx.varsN...)\n\t}\n\treturn varNames, nil\n}\n\n// prepareVars converts the route variable pairs into a map. If the route has a\n// BuildVarsFunc, it is invoked.\nfunc (r *Route) prepareVars(pairs ...string) (map[string]string, error) {\n\tm, err := mapFromPairsToString(pairs...)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn r.buildVars(m), nil\n}\n\nfunc (r *Route) buildVars(m map[string]string) map[string]string {\n\tif r.buildVarsFunc != nil {\n\t\tm = r.buildVarsFunc(m)\n\t}\n\treturn m\n}\n"
},
{
"path": "vendor/github.com/gorilla/mux/test_helpers.go",
"content": "// Copyright 2012 The Gorilla Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage mux\n\nimport \"net/http\"\n\n// SetURLVars sets the URL variables for the given request, to be accessed via\n// mux.Vars for testing route behaviour. Arguments are not modified, a shallow\n// copy is returned.\n//\n// This API should only be used for testing purposes; it provides a way to\n// inject variables into the request context. Alternatively, URL variables\n// can be set by making a route that captures the required variables,\n// starting a server and sending the request to that server.\nfunc SetURLVars(r *http.Request, val map[string]string) *http.Request {\n\treturn requestWithVars(r, val)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/LICENSE",
"content": "Copyright (c) 2009 The Go Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n"
},
{
"path": "vendor/golang.org/x/sys/PATENTS",
"content": "Additional IP Rights Grant (Patents)\n\n\"This implementation\" means the copyrightable works distributed by\nGoogle as part of the Go project.\n\nGoogle hereby grants to You a perpetual, worldwide, non-exclusive,\nno-charge, royalty-free, irrevocable (except as stated in this section)\npatent license to make, have made, use, offer to sell, sell, import,\ntransfer and otherwise run, modify and propagate the contents of this\nimplementation of Go, where such license applies only to those patent\nclaims, both currently owned or controlled by Google and acquired in\nthe future, licensable by Google that are necessarily infringed by this\nimplementation of Go. This grant does not include claims that would be\ninfringed only as a consequence of further modification of this\nimplementation. If you or your agent or exclusive licensee institute or\norder or agree to the institution of patent litigation against any\nentity (including a cross-claim or counterclaim in a lawsuit) alleging\nthat this implementation of Go or any code incorporated within this\nimplementation of Go constitutes direct or contributory patent\ninfringement, or inducement of patent infringement, then any patent\nrights granted to you under this License for this implementation of Go\nshall terminate as of the date such litigation is filed.\n"
},
{
"path": "vendor/golang.org/x/sys/unix/.gitignore",
"content": "_obj/\nunix.test\n"
},
{
"path": "vendor/golang.org/x/sys/unix/README.md",
"content": "# Building `sys/unix`\n\nThe sys/unix package provides access to the raw system call interface of the\nunderlying operating system. See: https://godoc.org/golang.org/x/sys/unix\n\nPorting Go to a new architecture/OS combination or adding syscalls, types, or\nconstants to an existing architecture/OS pair requires some manual effort;\nhowever, there are tools that automate much of the process.\n\n## Build Systems\n\nThere are currently two ways we generate the necessary files. We are currently\nmigrating the build system to use containers so the builds are reproducible.\nThis is being done on an OS-by-OS basis. Please update this documentation as\ncomponents of the build system change.\n\n### Old Build System (currently for `GOOS != \"linux\"`)\n\nThe old build system generates the Go files based on the C header files\npresent on your system. This means that files\nfor a given GOOS/GOARCH pair must be generated on a system with that OS and\narchitecture. This also means that the generated code can differ from system\nto system, based on differences in the header files.\n\nTo avoid this, if you are using the old build system, only generate the Go\nfiles on an installation with unmodified header files. It is also important to\nkeep track of which version of the OS the files were generated from (ex.\nDarwin 14 vs Darwin 15). This makes it easier to track the progress of changes\nand have each OS upgrade correspond to a single change.\n\nTo build the files for your current OS and architecture, make sure GOOS and\nGOARCH are set correctly and run `mkall.sh`. This will generate the files for\nyour specific system. Running `mkall.sh -n` shows the commands that will be run.\n\nRequirements: bash, go\n\n### New Build System (currently for `GOOS == \"linux\"`)\n\nThe new build system uses a Docker container to generate the go files directly\nfrom source checkouts of the kernel and various system libraries. This means\nthat on any platform that supports Docker, all the files using the new build\nsystem can be generated at once, and generated files will not change based on\nwhat the person running the scripts has installed on their computer.\n\nThe OS specific files for the new build system are located in the `${GOOS}`\ndirectory, and the build is coordinated by the `${GOOS}/mkall.go` program. When\nthe kernel or system library updates, modify the Dockerfile at\n`${GOOS}/Dockerfile` to checkout the new release of the source.\n\nTo build all the files under the new build system, you must be on an amd64/Linux\nsystem and have your GOOS and GOARCH set accordingly. Running `mkall.sh` will\nthen generate all of the files for all of the GOOS/GOARCH pairs in the new build\nsystem. Running `mkall.sh -n` shows the commands that will be run.\n\nRequirements: bash, go, docker\n\n## Component files\n\nThis section describes the various files used in the code generation process.\nIt also contains instructions on how to modify these files to add a new\narchitecture/OS or to add additional syscalls, types, or constants. Note that\nif you are using the new build system, the scripts/programs cannot be called normally.\nThey must be called from within the docker container.\n\n### asm files\n\nThe hand-written assembly file at `asm_${GOOS}_${GOARCH}.s` implements system\ncall dispatch. There are three entry points:\n```\n func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)\n func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr)\n func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)\n```\nThe first and second are the standard ones; they differ only in how many\narguments can be passed to the kernel. The third is for low-level use by the\nForkExec wrapper. Unlike the first two, it does not call into the scheduler to\nlet it know that a system call is running.\n\nWhen porting Go to a new architecture/OS, this file must be implemented for\neach GOOS/GOARCH pair.\n\n### mksysnum\n\nMksysnum is a Go program located at `${GOOS}/mksysnum.go` (or `mksysnum_${GOOS}.go`\nfor the old system). This program takes in a list of header files containing the\nsyscall number declarations and parses them to produce the corresponding list of\nGo numeric constants. See `zsysnum_${GOOS}_${GOARCH}.go` for the generated\nconstants.\n\nAdding new syscall numbers is mostly done by running the build on a sufficiently\nnew installation of the target OS (or updating the source checkouts for the\nnew build system). However, depending on the OS, you may need to update the\nparsing in mksysnum.\n\n### mksyscall.go\n\nThe `syscall.go`, `syscall_${GOOS}.go`, `syscall_${GOOS}_${GOARCH}.go` are\nhand-written Go files which implement system calls (for unix, the specific OS,\nor the specific OS/Architecture pair respectively) that need special handling\nand list `//sys` comments giving prototypes for ones that can be generated.\n\nThe mksyscall.go program takes the `//sys` and `//sysnb` comments and converts\nthem into syscalls. This requires the name of the prototype in the comment to\nmatch a syscall number in the `zsysnum_${GOOS}_${GOARCH}.go` file. The function\nprototype can be exported (capitalized) or not.\n\nAdding a new syscall often just requires adding a new `//sys` function prototype\nwith the desired arguments and a capitalized name so it is exported. However, if\nyou want the interface to the syscall to be different, often one will make an\nunexported `//sys` prototype, and then write a custom wrapper in\n`syscall_${GOOS}.go`.\n\n### types files\n\nFor each OS, there is a hand-written Go file at `${GOOS}/types.go` (or\n`types_${GOOS}.go` on the old system). This file includes standard C headers and\ncreates Go type aliases to the corresponding C types. The file is then fed\nthrough godef to get the Go compatible definitions. Finally, the generated code\nis fed though mkpost.go to format the code correctly and remove any hidden or\nprivate identifiers. This cleaned-up code is written to\n`ztypes_${GOOS}_${GOARCH}.go`.\n\nThe hardest part about preparing this file is figuring out which headers to\ninclude and which symbols need to be `#define`d to get the actual data\nstructures that pass through to the kernel system calls. Some C libraries\npreset alternate versions for binary compatibility and translate them on the\nway in and out of system calls, but there is almost always a `#define` that can\nget the real ones.\nSee `types_darwin.go` and `linux/types.go` for examples.\n\nTo add a new type, add in the necessary include statement at the top of the\nfile (if it is not already there) and add in a type alias line. Note that if\nyour type is significantly different on different architectures, you may need\nsome `#if/#elif` macros in your include statements.\n\n### mkerrors.sh\n\nThis script is used to generate the system's various constants. This doesn't\njust include the error numbers and error strings, but also the signal numbers\nand a wide variety of miscellaneous constants. The constants come from the list\nof include files in the `includes_${uname}` variable. A regex then picks out\nthe desired `#define` statements, and generates the corresponding Go constants.\nThe error numbers and strings are generated from `#include `, and the\nsignal numbers and strings are generated from `#include `. All of\nthese constants are written to `zerrors_${GOOS}_${GOARCH}.go` via a C program,\n`_errors.c`, which prints out all the constants.\n\nTo add a constant, add the header that includes it to the appropriate variable.\nThen, edit the regex (if necessary) to match the desired constant. Avoid making\nthe regex too broad to avoid matching unintended constants.\n\n### internal/mkmerge\n\nThis program is used to extract duplicate const, func, and type declarations\nfrom the generated architecture-specific files listed below, and merge these\ninto a common file for each OS.\n\nThe merge is performed in the following steps:\n1. Construct the set of common code that is idential in all architecture-specific files.\n2. Write this common code to the merged file.\n3. Remove the common code from all architecture-specific files.\n\n\n## Generated files\n\n### `zerrors_${GOOS}_${GOARCH}.go`\n\nA file containing all of the system's generated error numbers, error strings,\nsignal numbers, and constants. Generated by `mkerrors.sh` (see above).\n\n### `zsyscall_${GOOS}_${GOARCH}.go`\n\nA file containing all the generated syscalls for a specific GOOS and GOARCH.\nGenerated by `mksyscall.go` (see above).\n\n### `zsysnum_${GOOS}_${GOARCH}.go`\n\nA list of numeric constants for all the syscall number of the specific GOOS\nand GOARCH. Generated by mksysnum (see above).\n\n### `ztypes_${GOOS}_${GOARCH}.go`\n\nA file containing Go types for passing into (or returning from) syscalls.\nGenerated by godefs and the types file (see above).\n"
},
{
"path": "vendor/golang.org/x/sys/unix/affinity_linux.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// CPU affinity functions\n\npackage unix\n\nimport (\n\t\"math/bits\"\n\t\"unsafe\"\n)\n\nconst cpuSetSize = _CPU_SETSIZE / _NCPUBITS\n\n// CPUSet represents a CPU affinity mask.\ntype CPUSet [cpuSetSize]cpuMask\n\nfunc schedAffinity(trap uintptr, pid int, set *CPUSet) error {\n\t_, _, e := RawSyscall(trap, uintptr(pid), uintptr(unsafe.Sizeof(*set)), uintptr(unsafe.Pointer(set)))\n\tif e != 0 {\n\t\treturn errnoErr(e)\n\t}\n\treturn nil\n}\n\n// SchedGetaffinity gets the CPU affinity mask of the thread specified by pid.\n// If pid is 0 the calling thread is used.\nfunc SchedGetaffinity(pid int, set *CPUSet) error {\n\treturn schedAffinity(SYS_SCHED_GETAFFINITY, pid, set)\n}\n\n// SchedSetaffinity sets the CPU affinity mask of the thread specified by pid.\n// If pid is 0 the calling thread is used.\nfunc SchedSetaffinity(pid int, set *CPUSet) error {\n\treturn schedAffinity(SYS_SCHED_SETAFFINITY, pid, set)\n}\n\n// Zero clears the set s, so that it contains no CPUs.\nfunc (s *CPUSet) Zero() {\n\tfor i := range s {\n\t\ts[i] = 0\n\t}\n}\n\nfunc cpuBitsIndex(cpu int) int {\n\treturn cpu / _NCPUBITS\n}\n\nfunc cpuBitsMask(cpu int) cpuMask {\n\treturn cpuMask(1 << (uint(cpu) % _NCPUBITS))\n}\n\n// Set adds cpu to the set s.\nfunc (s *CPUSet) Set(cpu int) {\n\ti := cpuBitsIndex(cpu)\n\tif i < len(s) {\n\t\ts[i] |= cpuBitsMask(cpu)\n\t}\n}\n\n// Clear removes cpu from the set s.\nfunc (s *CPUSet) Clear(cpu int) {\n\ti := cpuBitsIndex(cpu)\n\tif i < len(s) {\n\t\ts[i] &^= cpuBitsMask(cpu)\n\t}\n}\n\n// IsSet reports whether cpu is in the set s.\nfunc (s *CPUSet) IsSet(cpu int) bool {\n\ti := cpuBitsIndex(cpu)\n\tif i < len(s) {\n\t\treturn s[i]&cpuBitsMask(cpu) != 0\n\t}\n\treturn false\n}\n\n// Count returns the number of CPUs in the set s.\nfunc (s *CPUSet) Count() int {\n\tc := 0\n\tfor _, b := range s {\n\t\tc += bits.OnesCount64(uint64(b))\n\t}\n\treturn c\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/aliases.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos\n\npackage unix\n\nimport \"syscall\"\n\ntype Signal = syscall.Signal\ntype Errno = syscall.Errno\ntype SysProcAttr = syscall.SysProcAttr\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_aix_ppc64.s",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for ppc64, AIX are implemented in runtime/syscall_aix.go\n//\n\nTEXT ·syscall6(SB),NOSPLIT,$0-88\n\tJMP\tsyscall·syscall6(SB)\n\nTEXT ·rawSyscall6(SB),NOSPLIT,$0-88\n\tJMP\tsyscall·rawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_386.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (freebsd || netbsd || openbsd) && gc\n\n#include \"textflag.h\"\n\n// System call support for 386 BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-40\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-52\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-40\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_amd64.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (darwin || dragonfly || freebsd || netbsd || openbsd) && gc\n\n#include \"textflag.h\"\n\n// System call support for AMD64 BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-104\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_arm.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (freebsd || netbsd || openbsd) && gc\n\n#include \"textflag.h\"\n\n// System call support for ARM BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-28\n\tB\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-40\n\tB\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-52\n\tB\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-28\n\tB\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-40\n\tB\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_arm64.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (darwin || freebsd || netbsd || openbsd) && gc\n\n#include \"textflag.h\"\n\n// System call support for ARM64 BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-104\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_ppc64.s",
"content": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (darwin || freebsd || netbsd || openbsd) && gc\n\n#include \"textflag.h\"\n\n//\n// System call support for ppc64, BSD\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-104\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_bsd_riscv64.s",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (darwin || freebsd || netbsd || openbsd) && gc\n\n#include \"textflag.h\"\n\n// System call support for RISCV64 BSD\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-104\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_386.s",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for 386, Linux\n//\n\n// See ../runtime/sys_linux_386.s for the reason why we always use int 0x80\n// instead of the glibc-specific \"CALL 0x10(GS)\".\n#define INVOKE_SYSCALL\tINT\t$0x80\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-40\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-24\n\tCALL\truntime·entersyscall(SB)\n\tMOVL\ttrap+0(FP), AX // syscall entry\n\tMOVL\ta1+4(FP), BX\n\tMOVL\ta2+8(FP), CX\n\tMOVL\ta3+12(FP), DX\n\tMOVL\t$0, SI\n\tMOVL\t$0, DI\n\tINVOKE_SYSCALL\n\tMOVL\tAX, r1+16(FP)\n\tMOVL\tDX, r2+20(FP)\n\tCALL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-40\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24\n\tMOVL\ttrap+0(FP), AX // syscall entry\n\tMOVL\ta1+4(FP), BX\n\tMOVL\ta2+8(FP), CX\n\tMOVL\ta3+12(FP), DX\n\tMOVL\t$0, SI\n\tMOVL\t$0, DI\n\tINVOKE_SYSCALL\n\tMOVL\tAX, r1+16(FP)\n\tMOVL\tDX, r2+20(FP)\n\tRET\n\nTEXT ·socketcall(SB),NOSPLIT,$0-36\n\tJMP\tsyscall·socketcall(SB)\n\nTEXT ·rawsocketcall(SB),NOSPLIT,$0-36\n\tJMP\tsyscall·rawsocketcall(SB)\n\nTEXT ·seek(SB),NOSPLIT,$0-28\n\tJMP\tsyscall·seek(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_amd64.s",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for AMD64, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tCALL\truntime·entersyscall(SB)\n\tMOVQ\ta1+8(FP), DI\n\tMOVQ\ta2+16(FP), SI\n\tMOVQ\ta3+24(FP), DX\n\tMOVQ\t$0, R10\n\tMOVQ\t$0, R8\n\tMOVQ\t$0, R9\n\tMOVQ\ttrap+0(FP), AX\t// syscall entry\n\tSYSCALL\n\tMOVQ\tAX, r1+32(FP)\n\tMOVQ\tDX, r2+40(FP)\n\tCALL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVQ\ta1+8(FP), DI\n\tMOVQ\ta2+16(FP), SI\n\tMOVQ\ta3+24(FP), DX\n\tMOVQ\t$0, R10\n\tMOVQ\t$0, R8\n\tMOVQ\t$0, R9\n\tMOVQ\ttrap+0(FP), AX\t// syscall entry\n\tSYSCALL\n\tMOVQ\tAX, r1+32(FP)\n\tMOVQ\tDX, r2+40(FP)\n\tRET\n\nTEXT ·gettimeofday(SB),NOSPLIT,$0-16\n\tJMP\tsyscall·gettimeofday(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_arm.s",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for arm, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-28\n\tB\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-40\n\tB\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-24\n\tBL\truntime·entersyscall(SB)\n\tMOVW\ttrap+0(FP), R7\n\tMOVW\ta1+4(FP), R0\n\tMOVW\ta2+8(FP), R1\n\tMOVW\ta3+12(FP), R2\n\tMOVW\t$0, R3\n\tMOVW\t$0, R4\n\tMOVW\t$0, R5\n\tSWI\t$0\n\tMOVW\tR0, r1+16(FP)\n\tMOVW\t$0, R0\n\tMOVW\tR0, r2+20(FP)\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-28\n\tB\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-40\n\tB\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24\n\tMOVW\ttrap+0(FP), R7\t// syscall entry\n\tMOVW\ta1+4(FP), R0\n\tMOVW\ta2+8(FP), R1\n\tMOVW\ta3+12(FP), R2\n\tSWI\t$0\n\tMOVW\tR0, r1+16(FP)\n\tMOVW\t$0, R0\n\tMOVW\tR0, r2+20(FP)\n\tRET\n\nTEXT ·seek(SB),NOSPLIT,$0-28\n\tB\tsyscall·seek(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_arm64.s",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && arm64 && gc\n\n#include \"textflag.h\"\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tB\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tB\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R0\n\tMOVD\ta2+16(FP), R1\n\tMOVD\ta3+24(FP), R2\n\tMOVD\t$0, R3\n\tMOVD\t$0, R4\n\tMOVD\t$0, R5\n\tMOVD\ttrap+0(FP), R8\t// syscall entry\n\tSVC\n\tMOVD\tR0, r1+32(FP)\t// r1\n\tMOVD\tR1, r2+40(FP)\t// r2\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tB\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tB\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVD\ta1+8(FP), R0\n\tMOVD\ta2+16(FP), R1\n\tMOVD\ta3+24(FP), R2\n\tMOVD\t$0, R3\n\tMOVD\t$0, R4\n\tMOVD\t$0, R5\n\tMOVD\ttrap+0(FP), R8\t// syscall entry\n\tSVC\n\tMOVD\tR0, r1+32(FP)\n\tMOVD\tR1, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_loong64.s",
"content": "// Copyright 2022 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && loong64 && gc\n\n#include \"textflag.h\"\n\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tJAL\truntime·entersyscall(SB)\n\tMOVV\ta1+8(FP), R4\n\tMOVV\ta2+16(FP), R5\n\tMOVV\ta3+24(FP), R6\n\tMOVV\tR0, R7\n\tMOVV\tR0, R8\n\tMOVV\tR0, R9\n\tMOVV\ttrap+0(FP), R11\t// syscall entry\n\tSYSCALL\n\tMOVV\tR4, r1+32(FP)\n\tMOVV\tR0, r2+40(FP)\t// r2 is not used. Always set to 0\n\tJAL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVV\ta1+8(FP), R4\n\tMOVV\ta2+16(FP), R5\n\tMOVV\ta3+24(FP), R6\n\tMOVV\tR0, R7\n\tMOVV\tR0, R8\n\tMOVV\tR0, R9\n\tMOVV\ttrap+0(FP), R11\t// syscall entry\n\tSYSCALL\n\tMOVV\tR4, r1+32(FP)\n\tMOVV\tR0, r2+40(FP)\t// r2 is not used. Always set to 0\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_mips64x.s",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && (mips64 || mips64le) && gc\n\n#include \"textflag.h\"\n\n//\n// System calls for mips64, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tJAL\truntime·entersyscall(SB)\n\tMOVV\ta1+8(FP), R4\n\tMOVV\ta2+16(FP), R5\n\tMOVV\ta3+24(FP), R6\n\tMOVV\tR0, R7\n\tMOVV\tR0, R8\n\tMOVV\tR0, R9\n\tMOVV\ttrap+0(FP), R2\t// syscall entry\n\tSYSCALL\n\tMOVV\tR2, r1+32(FP)\n\tMOVV\tR3, r2+40(FP)\n\tJAL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVV\ta1+8(FP), R4\n\tMOVV\ta2+16(FP), R5\n\tMOVV\ta3+24(FP), R6\n\tMOVV\tR0, R7\n\tMOVV\tR0, R8\n\tMOVV\tR0, R9\n\tMOVV\ttrap+0(FP), R2\t// syscall entry\n\tSYSCALL\n\tMOVV\tR2, r1+32(FP)\n\tMOVV\tR3, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_mipsx.s",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && (mips || mipsle) && gc\n\n#include \"textflag.h\"\n\n//\n// System calls for mips, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-28\n\tJMP syscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-40\n\tJMP syscall·Syscall6(SB)\n\nTEXT ·Syscall9(SB),NOSPLIT,$0-52\n\tJMP syscall·Syscall9(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-24\n\tJAL\truntime·entersyscall(SB)\n\tMOVW\ta1+4(FP), R4\n\tMOVW\ta2+8(FP), R5\n\tMOVW\ta3+12(FP), R6\n\tMOVW\tR0, R7\n\tMOVW\ttrap+0(FP), R2\t// syscall entry\n\tSYSCALL\n\tMOVW\tR2, r1+16(FP)\t// r1\n\tMOVW\tR3, r2+20(FP)\t// r2\n\tJAL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-28\n\tJMP syscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-40\n\tJMP syscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24\n\tMOVW\ta1+4(FP), R4\n\tMOVW\ta2+8(FP), R5\n\tMOVW\ta3+12(FP), R6\n\tMOVW\ttrap+0(FP), R2\t// syscall entry\n\tSYSCALL\n\tMOVW\tR2, r1+16(FP)\n\tMOVW\tR3, r2+20(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s",
"content": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && (ppc64 || ppc64le) && gc\n\n#include \"textflag.h\"\n\n//\n// System calls for ppc64, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R3\n\tMOVD\ta2+16(FP), R4\n\tMOVD\ta3+24(FP), R5\n\tMOVD\tR0, R6\n\tMOVD\tR0, R7\n\tMOVD\tR0, R8\n\tMOVD\ttrap+0(FP), R9\t// syscall entry\n\tSYSCALL R9\n\tMOVD\tR3, r1+32(FP)\n\tMOVD\tR4, r2+40(FP)\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVD\ta1+8(FP), R3\n\tMOVD\ta2+16(FP), R4\n\tMOVD\ta3+24(FP), R5\n\tMOVD\tR0, R6\n\tMOVD\tR0, R7\n\tMOVD\tR0, R8\n\tMOVD\ttrap+0(FP), R9\t// syscall entry\n\tSYSCALL R9\n\tMOVD\tR3, r1+32(FP)\n\tMOVD\tR4, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_riscv64.s",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build riscv64 && gc\n\n#include \"textflag.h\"\n\n//\n// System calls for linux/riscv64.\n//\n// Where available, just jump to package syscall's implementation of\n// these functions.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tCALL\truntime·entersyscall(SB)\n\tMOV\ta1+8(FP), A0\n\tMOV\ta2+16(FP), A1\n\tMOV\ta3+24(FP), A2\n\tMOV\ttrap+0(FP), A7\t// syscall entry\n\tECALL\n\tMOV\tA0, r1+32(FP)\t// r1\n\tMOV\tA1, r2+40(FP)\t// r2\n\tCALL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOV\ta1+8(FP), A0\n\tMOV\ta2+16(FP), A1\n\tMOV\ta3+24(FP), A2\n\tMOV\ttrap+0(FP), A7\t// syscall entry\n\tECALL\n\tMOV\tA0, r1+32(FP)\n\tMOV\tA1, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_linux_s390x.s",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux && s390x && gc\n\n#include \"textflag.h\"\n\n//\n// System calls for s390x, Linux\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT ·Syscall(SB),NOSPLIT,$0-56\n\tBR\tsyscall·Syscall(SB)\n\nTEXT ·Syscall6(SB),NOSPLIT,$0-80\n\tBR\tsyscall·Syscall6(SB)\n\nTEXT ·SyscallNoError(SB),NOSPLIT,$0-48\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R2\n\tMOVD\ta2+16(FP), R3\n\tMOVD\ta3+24(FP), R4\n\tMOVD\t$0, R5\n\tMOVD\t$0, R6\n\tMOVD\t$0, R7\n\tMOVD\ttrap+0(FP), R1\t// syscall entry\n\tSYSCALL\n\tMOVD\tR2, r1+32(FP)\n\tMOVD\tR3, r2+40(FP)\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·RawSyscall(SB),NOSPLIT,$0-56\n\tBR\tsyscall·RawSyscall(SB)\n\nTEXT ·RawSyscall6(SB),NOSPLIT,$0-80\n\tBR\tsyscall·RawSyscall6(SB)\n\nTEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48\n\tMOVD\ta1+8(FP), R2\n\tMOVD\ta2+16(FP), R3\n\tMOVD\ta3+24(FP), R4\n\tMOVD\t$0, R5\n\tMOVD\t$0, R6\n\tMOVD\t$0, R7\n\tMOVD\ttrap+0(FP), R1\t// syscall entry\n\tSYSCALL\n\tMOVD\tR2, r1+32(FP)\n\tMOVD\tR3, r2+40(FP)\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_openbsd_mips64.s",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n\n#include \"textflag.h\"\n\n//\n// System call support for mips64, OpenBSD\n//\n\n// Just jump to package syscall's implementation for all these functions.\n// The runtime may know about them.\n\nTEXT\t·Syscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·Syscall(SB)\n\nTEXT\t·Syscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·Syscall6(SB)\n\nTEXT\t·Syscall9(SB),NOSPLIT,$0-104\n\tJMP\tsyscall·Syscall9(SB)\n\nTEXT\t·RawSyscall(SB),NOSPLIT,$0-56\n\tJMP\tsyscall·RawSyscall(SB)\n\nTEXT\t·RawSyscall6(SB),NOSPLIT,$0-80\n\tJMP\tsyscall·RawSyscall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_solaris_amd64.s",
"content": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gc\n\n#include \"textflag.h\"\n\n//\n// System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go\n//\n\nTEXT ·sysvicall6(SB),NOSPLIT,$0-88\n\tJMP\tsyscall·sysvicall6(SB)\n\nTEXT ·rawSysvicall6(SB),NOSPLIT,$0-88\n\tJMP\tsyscall·rawSysvicall6(SB)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/asm_zos_s390x.s",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x && gc\n\n#include \"textflag.h\"\n\n#define PSALAA 1208(R0)\n#define GTAB64(x) 80(x)\n#define LCA64(x) 88(x)\n#define CAA(x) 8(x)\n#define EDCHPXV(x) 1016(x) // in the CAA\n#define SAVSTACK_ASYNC(x) 336(x) // in the LCA\n\n// SS_*, where x=SAVSTACK_ASYNC\n#define SS_LE(x) 0(x)\n#define SS_GO(x) 8(x)\n#define SS_ERRNO(x) 16(x)\n#define SS_ERRNOJR(x) 20(x)\n\n#define LE_CALL BYTE $0x0D; BYTE $0x76; // BL R7, R6\n\nTEXT ·clearErrno(SB),NOSPLIT,$0-0\n\tBL\taddrerrno<>(SB)\n\tMOVD\t$0, 0(R3)\n\tRET\n\n// Returns the address of errno in R3.\nTEXT addrerrno<>(SB),NOSPLIT|NOFRAME,$0-0\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get __errno FuncDesc.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tADD\t$(0x156*16), R9\n\tLMG\t0(R9), R5, R6\n\n\t// Switch to saved LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Call __errno function.\n\tLE_CALL\n\tNOPH\n\n\t// Switch back to Go stack.\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\tRET\n\nTEXT ·syscall_syscall(SB),NOSPLIT,$0-56\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+32(FP)\n\tMOVD\tR0, r2+40(FP)\n\tMOVD\tR0, err+48(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+48(FP)\ndone:\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·syscall_rawsyscall(SB),NOSPLIT,$0-56\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+32(FP)\n\tMOVD\tR0, r2+40(FP)\n\tMOVD\tR0, err+48(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+48(FP)\ndone:\n\tRET\n\nTEXT ·syscall_syscall6(SB),NOSPLIT,$0-80\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Fill in parameter list.\n\tMOVD\ta4+32(FP), R12\n\tMOVD\tR12, (2176+24)(R4)\n\tMOVD\ta5+40(FP), R12\n\tMOVD\tR12, (2176+32)(R4)\n\tMOVD\ta6+48(FP), R12\n\tMOVD\tR12, (2176+40)(R4)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+56(FP)\n\tMOVD\tR0, r2+64(FP)\n\tMOVD\tR0, err+72(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+72(FP)\ndone:\n\tBL\truntime·exitsyscall(SB)\n\tRET\n\nTEXT ·syscall_rawsyscall6(SB),NOSPLIT,$0-80\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Fill in parameter list.\n\tMOVD\ta4+32(FP), R12\n\tMOVD\tR12, (2176+24)(R4)\n\tMOVD\ta5+40(FP), R12\n\tMOVD\tR12, (2176+32)(R4)\n\tMOVD\ta6+48(FP), R12\n\tMOVD\tR12, (2176+40)(R4)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+56(FP)\n\tMOVD\tR0, r2+64(FP)\n\tMOVD\tR0, err+72(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\t·rrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+72(FP)\ndone:\n\tRET\n\nTEXT ·syscall_syscall9(SB),NOSPLIT,$0\n\tBL\truntime·entersyscall(SB)\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Fill in parameter list.\n\tMOVD\ta4+32(FP), R12\n\tMOVD\tR12, (2176+24)(R4)\n\tMOVD\ta5+40(FP), R12\n\tMOVD\tR12, (2176+32)(R4)\n\tMOVD\ta6+48(FP), R12\n\tMOVD\tR12, (2176+40)(R4)\n\tMOVD\ta7+56(FP), R12\n\tMOVD\tR12, (2176+48)(R4)\n\tMOVD\ta8+64(FP), R12\n\tMOVD\tR12, (2176+56)(R4)\n\tMOVD\ta9+72(FP), R12\n\tMOVD\tR12, (2176+64)(R4)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+80(FP)\n\tMOVD\tR0, r2+88(FP)\n\tMOVD\tR0, err+96(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+96(FP)\ndone:\n BL\truntime·exitsyscall(SB)\n RET\n\nTEXT ·syscall_rawsyscall9(SB),NOSPLIT,$0\n\tMOVD\ta1+8(FP), R1\n\tMOVD\ta2+16(FP), R2\n\tMOVD\ta3+24(FP), R3\n\n\t// Get library control area (LCA).\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\n\t// Get function.\n\tMOVD\tCAA(R8), R9\n\tMOVD\tEDCHPXV(R9), R9\n\tMOVD\ttrap+0(FP), R5\n\tSLD\t$4, R5\n\tADD\tR5, R9\n\tLMG\t0(R9), R5, R6\n\n\t// Restore LE stack.\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R4\n\tMOVD\t$0, 0(R9)\n\n\t// Fill in parameter list.\n\tMOVD\ta4+32(FP), R12\n\tMOVD\tR12, (2176+24)(R4)\n\tMOVD\ta5+40(FP), R12\n\tMOVD\tR12, (2176+32)(R4)\n\tMOVD\ta6+48(FP), R12\n\tMOVD\tR12, (2176+40)(R4)\n\tMOVD\ta7+56(FP), R12\n\tMOVD\tR12, (2176+48)(R4)\n\tMOVD\ta8+64(FP), R12\n\tMOVD\tR12, (2176+56)(R4)\n\tMOVD\ta9+72(FP), R12\n\tMOVD\tR12, (2176+64)(R4)\n\n\t// Call function.\n\tLE_CALL\n\tNOPH\n\tXOR\tR0, R0 // Restore R0 to $0.\n\tMOVD\tR4, 0(R9) // Save stack pointer.\n\n\tMOVD\tR3, r1+80(FP)\n\tMOVD\tR0, r2+88(FP)\n\tMOVD\tR0, err+96(FP)\n\tMOVW\tR3, R4\n\tCMP\tR4, $-1\n\tBNE\tdone\n\tBL\taddrerrno<>(SB)\n\tMOVWZ\t0(R3), R3\n\tMOVD\tR3, err+96(FP)\ndone:\n\tRET\n\n// func svcCall(fnptr unsafe.Pointer, argv *unsafe.Pointer, dsa *uint64)\nTEXT ·svcCall(SB),NOSPLIT,$0\n\tBL\truntime·save_g(SB) // Save g and stack pointer\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\tR15, 0(R9)\n\n\tMOVD\targv+8(FP), R1 // Move function arguments into registers\n\tMOVD\tdsa+16(FP), g\n\tMOVD\tfnptr+0(FP), R15\n\n\tBYTE\t$0x0D // Branch to function\n\tBYTE\t$0xEF\n\n\tBL\truntime·load_g(SB) // Restore g and stack pointer\n\tMOVW\tPSALAA, R8\n\tMOVD\tLCA64(R8), R8\n\tMOVD\tSAVSTACK_ASYNC(R8), R9\n\tMOVD\t0(R9), R15\n\n\tRET\n\n// func svcLoad(name *byte) unsafe.Pointer\nTEXT ·svcLoad(SB),NOSPLIT,$0\n\tMOVD\tR15, R2 // Save go stack pointer\n\tMOVD\tname+0(FP), R0 // Move SVC args into registers\n\tMOVD\t$0x80000000, R1\n\tMOVD\t$0, R15\n\tBYTE\t$0x0A // SVC 08 LOAD\n\tBYTE\t$0x08\n\tMOVW\tR15, R3 // Save return code from SVC\n\tMOVD\tR2, R15 // Restore go stack pointer\n\tCMP\tR3, $0 // Check SVC return code\n\tBNE\terror\n\n\tMOVD\t$-2, R3 // Reset last bit of entry point to zero\n\tAND\tR0, R3\n\tMOVD\tR3, addr+8(FP) // Return entry point returned by SVC\n\tCMP\tR0, R3 // Check if last bit of entry point was set\n\tBNE\tdone\n\n\tMOVD\tR15, R2 // Save go stack pointer\n\tMOVD\t$0, R15 // Move SVC args into registers (entry point still in r0 from SVC 08)\n\tBYTE\t$0x0A // SVC 09 DELETE\n\tBYTE\t$0x09\n\tMOVD\tR2, R15 // Restore go stack pointer\n\nerror:\n\tMOVD\t$0, addr+8(FP) // Return 0 on failure\ndone:\n\tXOR\tR0, R0 // Reset r0 to 0\n\tRET\n\n// func svcUnload(name *byte, fnptr unsafe.Pointer) int64\nTEXT ·svcUnload(SB),NOSPLIT,$0\n\tMOVD\tR15, R2 // Save go stack pointer\n\tMOVD\tname+0(FP), R0 // Move SVC args into registers\n\tMOVD\taddr+8(FP), R15\n\tBYTE\t$0x0A // SVC 09\n\tBYTE\t$0x09\n\tXOR\tR0, R0 // Reset r0 to 0\n\tMOVD\tR15, R1 // Save SVC return code\n\tMOVD\tR2, R15 // Restore go stack pointer\n\tMOVD\tR1, rc+0(FP) // Return SVC return code\n\tRET\n\n// func gettid() uint64\nTEXT ·gettid(SB), NOSPLIT, $0\n\t// Get library control area (LCA).\n\tMOVW PSALAA, R8\n\tMOVD LCA64(R8), R8\n\n\t// Get CEECAATHDID\n\tMOVD CAA(R8), R9\n\tMOVD 0x3D0(R9), R9\n\tMOVD R9, ret+0(FP)\n\n\tRET\n"
},
{
"path": "vendor/golang.org/x/sys/unix/bluetooth_linux.go",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Bluetooth sockets and messages\n\npackage unix\n\n// Bluetooth Protocols\nconst (\n\tBTPROTO_L2CAP = 0\n\tBTPROTO_HCI = 1\n\tBTPROTO_SCO = 2\n\tBTPROTO_RFCOMM = 3\n\tBTPROTO_BNEP = 4\n\tBTPROTO_CMTP = 5\n\tBTPROTO_HIDP = 6\n\tBTPROTO_AVDTP = 7\n)\n\nconst (\n\tHCI_CHANNEL_RAW = 0\n\tHCI_CHANNEL_USER = 1\n\tHCI_CHANNEL_MONITOR = 2\n\tHCI_CHANNEL_CONTROL = 3\n\tHCI_CHANNEL_LOGGING = 4\n)\n\n// Socketoption Level\nconst (\n\tSOL_BLUETOOTH = 0x112\n\tSOL_HCI = 0x0\n\tSOL_L2CAP = 0x6\n\tSOL_RFCOMM = 0x12\n\tSOL_SCO = 0x11\n)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/cap_freebsd.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build freebsd\n\npackage unix\n\nimport (\n\t\"errors\"\n\t\"fmt\"\n)\n\n// Go implementation of C mostly found in /usr/src/sys/kern/subr_capability.c\n\nconst (\n\t// This is the version of CapRights this package understands. See C implementation for parallels.\n\tcapRightsGoVersion = CAP_RIGHTS_VERSION_00\n\tcapArSizeMin = CAP_RIGHTS_VERSION_00 + 2\n\tcapArSizeMax = capRightsGoVersion + 2\n)\n\nvar (\n\tbit2idx = []int{\n\t\t-1, 0, 1, -1, 2, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1,\n\t\t4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n\t}\n)\n\nfunc capidxbit(right uint64) int {\n\treturn int((right >> 57) & 0x1f)\n}\n\nfunc rightToIndex(right uint64) (int, error) {\n\tidx := capidxbit(right)\n\tif idx < 0 || idx >= len(bit2idx) {\n\t\treturn -2, fmt.Errorf(\"index for right 0x%x out of range\", right)\n\t}\n\treturn bit2idx[idx], nil\n}\n\nfunc caprver(right uint64) int {\n\treturn int(right >> 62)\n}\n\nfunc capver(rights *CapRights) int {\n\treturn caprver(rights.Rights[0])\n}\n\nfunc caparsize(rights *CapRights) int {\n\treturn capver(rights) + 2\n}\n\n// CapRightsSet sets the permissions in setrights in rights.\nfunc CapRightsSet(rights *CapRights, setrights []uint64) error {\n\t// This is essentially a copy of cap_rights_vset()\n\tif capver(rights) != CAP_RIGHTS_VERSION_00 {\n\t\treturn fmt.Errorf(\"bad rights version %d\", capver(rights))\n\t}\n\n\tn := caparsize(rights)\n\tif n < capArSizeMin || n > capArSizeMax {\n\t\treturn errors.New(\"bad rights size\")\n\t}\n\n\tfor _, right := range setrights {\n\t\tif caprver(right) != CAP_RIGHTS_VERSION_00 {\n\t\t\treturn errors.New(\"bad right version\")\n\t\t}\n\t\ti, err := rightToIndex(right)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tif i >= n {\n\t\t\treturn errors.New(\"index overflow\")\n\t\t}\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn errors.New(\"index mismatch\")\n\t\t}\n\t\trights.Rights[i] |= right\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn errors.New(\"index mismatch (after assign)\")\n\t\t}\n\t}\n\n\treturn nil\n}\n\n// CapRightsClear clears the permissions in clearrights from rights.\nfunc CapRightsClear(rights *CapRights, clearrights []uint64) error {\n\t// This is essentially a copy of cap_rights_vclear()\n\tif capver(rights) != CAP_RIGHTS_VERSION_00 {\n\t\treturn fmt.Errorf(\"bad rights version %d\", capver(rights))\n\t}\n\n\tn := caparsize(rights)\n\tif n < capArSizeMin || n > capArSizeMax {\n\t\treturn errors.New(\"bad rights size\")\n\t}\n\n\tfor _, right := range clearrights {\n\t\tif caprver(right) != CAP_RIGHTS_VERSION_00 {\n\t\t\treturn errors.New(\"bad right version\")\n\t\t}\n\t\ti, err := rightToIndex(right)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tif i >= n {\n\t\t\treturn errors.New(\"index overflow\")\n\t\t}\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn errors.New(\"index mismatch\")\n\t\t}\n\t\trights.Rights[i] &= ^(right & 0x01FFFFFFFFFFFFFF)\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn errors.New(\"index mismatch (after assign)\")\n\t\t}\n\t}\n\n\treturn nil\n}\n\n// CapRightsIsSet checks whether all the permissions in setrights are present in rights.\nfunc CapRightsIsSet(rights *CapRights, setrights []uint64) (bool, error) {\n\t// This is essentially a copy of cap_rights_is_vset()\n\tif capver(rights) != CAP_RIGHTS_VERSION_00 {\n\t\treturn false, fmt.Errorf(\"bad rights version %d\", capver(rights))\n\t}\n\n\tn := caparsize(rights)\n\tif n < capArSizeMin || n > capArSizeMax {\n\t\treturn false, errors.New(\"bad rights size\")\n\t}\n\n\tfor _, right := range setrights {\n\t\tif caprver(right) != CAP_RIGHTS_VERSION_00 {\n\t\t\treturn false, errors.New(\"bad right version\")\n\t\t}\n\t\ti, err := rightToIndex(right)\n\t\tif err != nil {\n\t\t\treturn false, err\n\t\t}\n\t\tif i >= n {\n\t\t\treturn false, errors.New(\"index overflow\")\n\t\t}\n\t\tif capidxbit(rights.Rights[i]) != capidxbit(right) {\n\t\t\treturn false, errors.New(\"index mismatch\")\n\t\t}\n\t\tif (rights.Rights[i] & right) != right {\n\t\t\treturn false, nil\n\t\t}\n\t}\n\n\treturn true, nil\n}\n\nfunc capright(idx uint64, bit uint64) uint64 {\n\treturn ((1 << (57 + idx)) | bit)\n}\n\n// CapRightsInit returns a pointer to an initialised CapRights structure filled with rights.\n// See man cap_rights_init(3) and rights(4).\nfunc CapRightsInit(rights []uint64) (*CapRights, error) {\n\tvar r CapRights\n\tr.Rights[0] = (capRightsGoVersion << 62) | capright(0, 0)\n\tr.Rights[1] = capright(1, 0)\n\n\terr := CapRightsSet(&r, rights)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn &r, nil\n}\n\n// CapRightsLimit reduces the operations permitted on fd to at most those contained in rights.\n// The capability rights on fd can never be increased by CapRightsLimit.\n// See man cap_rights_limit(2) and rights(4).\nfunc CapRightsLimit(fd uintptr, rights *CapRights) error {\n\treturn capRightsLimit(int(fd), rights)\n}\n\n// CapRightsGet returns a CapRights structure containing the operations permitted on fd.\n// See man cap_rights_get(3) and rights(4).\nfunc CapRightsGet(fd uintptr) (*CapRights, error) {\n\tr, err := CapRightsInit(nil)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\terr = capRightsGet(capRightsGoVersion, int(fd), r)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\treturn r, nil\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/constants.go",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos\n\npackage unix\n\nconst (\n\tR_OK = 0x4\n\tW_OK = 0x2\n\tX_OK = 0x1\n)\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_aix_ppc.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix && ppc\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used by AIX.\n\npackage unix\n\n// Major returns the major component of a Linux device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 16) & 0xffff)\n}\n\n// Minor returns the minor component of a Linux device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0xffff)\n}\n\n// Mkdev returns a Linux device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn uint64(((major) << 16) | (minor))\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_aix_ppc64.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix && ppc64\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used AIX.\n\npackage unix\n\n// Major returns the major component of a Linux device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev & 0x3fffffff00000000) >> 32)\n}\n\n// Minor returns the minor component of a Linux device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32((dev & 0x00000000ffffffff) >> 0)\n}\n\n// Mkdev returns a Linux device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\tvar DEVNO64 uint64\n\tDEVNO64 = 0x8000000000000000\n\treturn ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_darwin.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in Darwin's sys/types.h header.\n\npackage unix\n\n// Major returns the major component of a Darwin device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 24) & 0xff)\n}\n\n// Minor returns the minor component of a Darwin device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0xffffff)\n}\n\n// Mkdev returns a Darwin device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn (uint64(major) << 24) | uint64(minor)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_dragonfly.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in Dragonfly's sys/types.h header.\n//\n// The information below is extracted and adapted from sys/types.h:\n//\n// Minor gives a cookie instead of an index since in order to avoid changing the\n// meanings of bits 0-15 or wasting time and space shifting bits 16-31 for\n// devices that don't use them.\n\npackage unix\n\n// Major returns the major component of a DragonFlyBSD device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 8) & 0xff)\n}\n\n// Minor returns the minor component of a DragonFlyBSD device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0xffff00ff)\n}\n\n// Mkdev returns a DragonFlyBSD device number generated from the given major and\n// minor components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn (uint64(major) << 8) | uint64(minor)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_freebsd.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in FreeBSD's sys/types.h header.\n//\n// The information below is extracted and adapted from sys/types.h:\n//\n// Minor gives a cookie instead of an index since in order to avoid changing the\n// meanings of bits 0-15 or wasting time and space shifting bits 16-31 for\n// devices that don't use them.\n\npackage unix\n\n// Major returns the major component of a FreeBSD device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 8) & 0xff)\n}\n\n// Minor returns the minor component of a FreeBSD device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0xffff00ff)\n}\n\n// Mkdev returns a FreeBSD device number generated from the given major and\n// minor components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn (uint64(major) << 8) | uint64(minor)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_linux.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used by the Linux kernel and glibc.\n//\n// The information below is extracted and adapted from bits/sysmacros.h in the\n// glibc sources:\n//\n// dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's\n// default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major\n// number and m is a hex digit of the minor number. This is backward compatible\n// with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also\n// backward compatible with the Linux kernel, which for some architectures uses\n// 32-bit dev_t, encoded as mmmM MMmm.\n\npackage unix\n\n// Major returns the major component of a Linux device number.\nfunc Major(dev uint64) uint32 {\n\tmajor := uint32((dev & 0x00000000000fff00) >> 8)\n\tmajor |= uint32((dev & 0xfffff00000000000) >> 32)\n\treturn major\n}\n\n// Minor returns the minor component of a Linux device number.\nfunc Minor(dev uint64) uint32 {\n\tminor := uint32((dev & 0x00000000000000ff) >> 0)\n\tminor |= uint32((dev & 0x00000ffffff00000) >> 12)\n\treturn minor\n}\n\n// Mkdev returns a Linux device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\tdev := (uint64(major) & 0x00000fff) << 8\n\tdev |= (uint64(major) & 0xfffff000) << 32\n\tdev |= (uint64(minor) & 0x000000ff) << 0\n\tdev |= (uint64(minor) & 0xffffff00) << 12\n\treturn dev\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_netbsd.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in NetBSD's sys/types.h header.\n\npackage unix\n\n// Major returns the major component of a NetBSD device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev & 0x000fff00) >> 8)\n}\n\n// Minor returns the minor component of a NetBSD device number.\nfunc Minor(dev uint64) uint32 {\n\tminor := uint32((dev & 0x000000ff) >> 0)\n\tminor |= uint32((dev & 0xfff00000) >> 12)\n\treturn minor\n}\n\n// Mkdev returns a NetBSD device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\tdev := (uint64(major) << 8) & 0x000fff00\n\tdev |= (uint64(minor) << 12) & 0xfff00000\n\tdev |= (uint64(minor) << 0) & 0x000000ff\n\treturn dev\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_openbsd.go",
"content": "// Copyright 2017 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used in OpenBSD's sys/types.h header.\n\npackage unix\n\n// Major returns the major component of an OpenBSD device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev & 0x0000ff00) >> 8)\n}\n\n// Minor returns the minor component of an OpenBSD device number.\nfunc Minor(dev uint64) uint32 {\n\tminor := uint32((dev & 0x000000ff) >> 0)\n\tminor |= uint32((dev & 0xffff0000) >> 8)\n\treturn minor\n}\n\n// Mkdev returns an OpenBSD device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\tdev := (uint64(major) << 8) & 0x0000ff00\n\tdev |= (uint64(minor) << 8) & 0xffff0000\n\tdev |= (uint64(minor) << 0) & 0x000000ff\n\treturn dev\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dev_zos.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x\n\n// Functions to access/create device major and minor numbers matching the\n// encoding used by z/OS.\n//\n// The information below is extracted and adapted from macros.\n\npackage unix\n\n// Major returns the major component of a z/OS device number.\nfunc Major(dev uint64) uint32 {\n\treturn uint32((dev >> 16) & 0x0000FFFF)\n}\n\n// Minor returns the minor component of a z/OS device number.\nfunc Minor(dev uint64) uint32 {\n\treturn uint32(dev & 0x0000FFFF)\n}\n\n// Mkdev returns a z/OS device number generated from the given major and minor\n// components.\nfunc Mkdev(major, minor uint32) uint64 {\n\treturn (uint64(major) << 16) | uint64(minor)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/dirent.go",
"content": "// Copyright 2009 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos\n\npackage unix\n\nimport \"unsafe\"\n\n// readInt returns the size-bytes unsigned integer in native byte order at offset off.\nfunc readInt(b []byte, off, size uintptr) (u uint64, ok bool) {\n\tif len(b) < int(off+size) {\n\t\treturn 0, false\n\t}\n\tif isBigEndian {\n\t\treturn readIntBE(b[off:], size), true\n\t}\n\treturn readIntLE(b[off:], size), true\n}\n\nfunc readIntBE(b []byte, size uintptr) uint64 {\n\tswitch size {\n\tcase 1:\n\t\treturn uint64(b[0])\n\tcase 2:\n\t\t_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[1]) | uint64(b[0])<<8\n\tcase 4:\n\t\t_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[3]) | uint64(b[2])<<8 | uint64(b[1])<<16 | uint64(b[0])<<24\n\tcase 8:\n\t\t_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[7]) | uint64(b[6])<<8 | uint64(b[5])<<16 | uint64(b[4])<<24 |\n\t\t\tuint64(b[3])<<32 | uint64(b[2])<<40 | uint64(b[1])<<48 | uint64(b[0])<<56\n\tdefault:\n\t\tpanic(\"syscall: readInt with unsupported size\")\n\t}\n}\n\nfunc readIntLE(b []byte, size uintptr) uint64 {\n\tswitch size {\n\tcase 1:\n\t\treturn uint64(b[0])\n\tcase 2:\n\t\t_ = b[1] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[0]) | uint64(b[1])<<8\n\tcase 4:\n\t\t_ = b[3] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24\n\tcase 8:\n\t\t_ = b[7] // bounds check hint to compiler; see golang.org/issue/14808\n\t\treturn uint64(b[0]) | uint64(b[1])<<8 | uint64(b[2])<<16 | uint64(b[3])<<24 |\n\t\t\tuint64(b[4])<<32 | uint64(b[5])<<40 | uint64(b[6])<<48 | uint64(b[7])<<56\n\tdefault:\n\t\tpanic(\"syscall: readInt with unsupported size\")\n\t}\n}\n\n// ParseDirent parses up to max directory entries in buf,\n// appending the names to names. It returns the number of\n// bytes consumed from buf, the number of entries added\n// to names, and the new names slice.\nfunc ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {\n\toriglen := len(buf)\n\tcount = 0\n\tfor max != 0 && len(buf) > 0 {\n\t\treclen, ok := direntReclen(buf)\n\t\tif !ok || reclen > uint64(len(buf)) {\n\t\t\treturn origlen, count, names\n\t\t}\n\t\trec := buf[:reclen]\n\t\tbuf = buf[reclen:]\n\t\tino, ok := direntIno(rec)\n\t\tif !ok {\n\t\t\tbreak\n\t\t}\n\t\tif ino == 0 { // File absent in directory.\n\t\t\tcontinue\n\t\t}\n\t\tconst namoff = uint64(unsafe.Offsetof(Dirent{}.Name))\n\t\tnamlen, ok := direntNamlen(rec)\n\t\tif !ok || namoff+namlen > uint64(len(rec)) {\n\t\t\tbreak\n\t\t}\n\t\tname := rec[namoff : namoff+namlen]\n\t\tfor i, c := range name {\n\t\t\tif c == 0 {\n\t\t\t\tname = name[:i]\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// Check for useless names before allocating a string.\n\t\tif string(name) == \".\" || string(name) == \"..\" {\n\t\t\tcontinue\n\t\t}\n\t\tmax--\n\t\tcount++\n\t\tnames = append(names, string(name))\n\t}\n\treturn origlen - len(buf), count, names\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/endian_big.go",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n//\n//go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64\n\npackage unix\n\nconst isBigEndian = true\n"
},
{
"path": "vendor/golang.org/x/sys/unix/endian_little.go",
"content": "// Copyright 2016 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n//\n//go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh\n\npackage unix\n\nconst isBigEndian = false\n"
},
{
"path": "vendor/golang.org/x/sys/unix/env_unix.go",
"content": "// Copyright 2010 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos\n\n// Unix environment variables.\n\npackage unix\n\nimport \"syscall\"\n\nfunc Getenv(key string) (value string, found bool) {\n\treturn syscall.Getenv(key)\n}\n\nfunc Setenv(key, value string) error {\n\treturn syscall.Setenv(key, value)\n}\n\nfunc Clearenv() {\n\tsyscall.Clearenv()\n}\n\nfunc Environ() []string {\n\treturn syscall.Environ()\n}\n\nfunc Unsetenv(key string) error {\n\treturn syscall.Unsetenv(key)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/epoll_zos.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x\n\npackage unix\n\nimport (\n\t\"sync\"\n)\n\n// This file simulates epoll on z/OS using poll.\n\n// Analogous to epoll_event on Linux.\n// TODO(neeilan): Pad is because the Linux kernel expects a 96-bit struct. We never pass this to the kernel; remove?\ntype EpollEvent struct {\n\tEvents uint32\n\tFd int32\n\tPad int32\n}\n\nconst (\n\tEPOLLERR = 0x8\n\tEPOLLHUP = 0x10\n\tEPOLLIN = 0x1\n\tEPOLLMSG = 0x400\n\tEPOLLOUT = 0x4\n\tEPOLLPRI = 0x2\n\tEPOLLRDBAND = 0x80\n\tEPOLLRDNORM = 0x40\n\tEPOLLWRBAND = 0x200\n\tEPOLLWRNORM = 0x100\n\tEPOLL_CTL_ADD = 0x1\n\tEPOLL_CTL_DEL = 0x2\n\tEPOLL_CTL_MOD = 0x3\n\t// The following constants are part of the epoll API, but represent\n\t// currently unsupported functionality on z/OS.\n\t// EPOLL_CLOEXEC = 0x80000\n\t// EPOLLET = 0x80000000\n\t// EPOLLONESHOT = 0x40000000\n\t// EPOLLRDHUP = 0x2000 // Typically used with edge-triggered notis\n\t// EPOLLEXCLUSIVE = 0x10000000 // Exclusive wake-up mode\n\t// EPOLLWAKEUP = 0x20000000 // Relies on Linux's BLOCK_SUSPEND capability\n)\n\n// TODO(neeilan): We can eliminate these epToPoll / pToEpoll calls by using identical mask values for POLL/EPOLL\n// constants where possible The lower 16 bits of epoll events (uint32) can fit any system poll event (int16).\n\n// epToPollEvt converts epoll event field to poll equivalent.\n// In epoll, Events is a 32-bit field, while poll uses 16 bits.\nfunc epToPollEvt(events uint32) int16 {\n\tvar ep2p = map[uint32]int16{\n\t\tEPOLLIN: POLLIN,\n\t\tEPOLLOUT: POLLOUT,\n\t\tEPOLLHUP: POLLHUP,\n\t\tEPOLLPRI: POLLPRI,\n\t\tEPOLLERR: POLLERR,\n\t}\n\n\tvar pollEvts int16 = 0\n\tfor epEvt, pEvt := range ep2p {\n\t\tif (events & epEvt) != 0 {\n\t\t\tpollEvts |= pEvt\n\t\t}\n\t}\n\n\treturn pollEvts\n}\n\n// pToEpollEvt converts 16 bit poll event bitfields to 32-bit epoll event fields.\nfunc pToEpollEvt(revents int16) uint32 {\n\tvar p2ep = map[int16]uint32{\n\t\tPOLLIN: EPOLLIN,\n\t\tPOLLOUT: EPOLLOUT,\n\t\tPOLLHUP: EPOLLHUP,\n\t\tPOLLPRI: EPOLLPRI,\n\t\tPOLLERR: EPOLLERR,\n\t}\n\n\tvar epollEvts uint32 = 0\n\tfor pEvt, epEvt := range p2ep {\n\t\tif (revents & pEvt) != 0 {\n\t\t\tepollEvts |= epEvt\n\t\t}\n\t}\n\n\treturn epollEvts\n}\n\n// Per-process epoll implementation.\ntype epollImpl struct {\n\tmu sync.Mutex\n\tepfd2ep map[int]*eventPoll\n\tnextEpfd int\n}\n\n// eventPoll holds a set of file descriptors being watched by the process. A process can have multiple epoll instances.\n// On Linux, this is an in-kernel data structure accessed through a fd.\ntype eventPoll struct {\n\tmu sync.Mutex\n\tfds map[int]*EpollEvent\n}\n\n// epoll impl for this process.\nvar impl epollImpl = epollImpl{\n\tepfd2ep: make(map[int]*eventPoll),\n\tnextEpfd: 0,\n}\n\nfunc (e *epollImpl) epollcreate(size int) (epfd int, err error) {\n\te.mu.Lock()\n\tdefer e.mu.Unlock()\n\tepfd = e.nextEpfd\n\te.nextEpfd++\n\n\te.epfd2ep[epfd] = &eventPoll{\n\t\tfds: make(map[int]*EpollEvent),\n\t}\n\treturn epfd, nil\n}\n\nfunc (e *epollImpl) epollcreate1(flag int) (fd int, err error) {\n\treturn e.epollcreate(4)\n}\n\nfunc (e *epollImpl) epollctl(epfd int, op int, fd int, event *EpollEvent) (err error) {\n\te.mu.Lock()\n\tdefer e.mu.Unlock()\n\n\tep, ok := e.epfd2ep[epfd]\n\tif !ok {\n\n\t\treturn EBADF\n\t}\n\n\tswitch op {\n\tcase EPOLL_CTL_ADD:\n\t\t// TODO(neeilan): When we make epfds and fds disjoint, detect epoll\n\t\t// loops here (instances watching each other) and return ELOOP.\n\t\tif _, ok := ep.fds[fd]; ok {\n\t\t\treturn EEXIST\n\t\t}\n\t\tep.fds[fd] = event\n\tcase EPOLL_CTL_MOD:\n\t\tif _, ok := ep.fds[fd]; !ok {\n\t\t\treturn ENOENT\n\t\t}\n\t\tep.fds[fd] = event\n\tcase EPOLL_CTL_DEL:\n\t\tif _, ok := ep.fds[fd]; !ok {\n\t\t\treturn ENOENT\n\t\t}\n\t\tdelete(ep.fds, fd)\n\n\t}\n\treturn nil\n}\n\n// Must be called while holding ep.mu\nfunc (ep *eventPoll) getFds() []int {\n\tfds := make([]int, len(ep.fds))\n\tfor fd := range ep.fds {\n\t\tfds = append(fds, fd)\n\t}\n\treturn fds\n}\n\nfunc (e *epollImpl) epollwait(epfd int, events []EpollEvent, msec int) (n int, err error) {\n\te.mu.Lock() // in [rare] case of concurrent epollcreate + epollwait\n\tep, ok := e.epfd2ep[epfd]\n\n\tif !ok {\n\t\te.mu.Unlock()\n\t\treturn 0, EBADF\n\t}\n\n\tpollfds := make([]PollFd, 4)\n\tfor fd, epollevt := range ep.fds {\n\t\tpollfds = append(pollfds, PollFd{Fd: int32(fd), Events: epToPollEvt(epollevt.Events)})\n\t}\n\te.mu.Unlock()\n\n\tn, err = Poll(pollfds, msec)\n\tif err != nil {\n\t\treturn n, err\n\t}\n\n\ti := 0\n\tfor _, pFd := range pollfds {\n\t\tif pFd.Revents != 0 {\n\t\t\tevents[i] = EpollEvent{Fd: pFd.Fd, Events: pToEpollEvt(pFd.Revents)}\n\t\t\ti++\n\t\t}\n\n\t\tif i == n {\n\t\t\tbreak\n\t\t}\n\t}\n\n\treturn n, nil\n}\n\nfunc EpollCreate(size int) (fd int, err error) {\n\treturn impl.epollcreate(size)\n}\n\nfunc EpollCreate1(flag int) (fd int, err error) {\n\treturn impl.epollcreate1(flag)\n}\n\nfunc EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {\n\treturn impl.epollctl(epfd, op, fd, event)\n}\n\n// Because EpollWait mutates events, the caller is expected to coordinate\n// concurrent access if calling with the same epfd from multiple goroutines.\nfunc EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {\n\treturn impl.epollwait(epfd, events, msec)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fcntl.go",
"content": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build dragonfly || freebsd || linux || netbsd\n\npackage unix\n\nimport \"unsafe\"\n\n// fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux\n// systems by fcntl_linux_32bit.go to be SYS_FCNTL64.\nvar fcntl64Syscall uintptr = SYS_FCNTL\n\nfunc fcntl(fd int, cmd, arg int) (int, error) {\n\tvalptr, _, errno := Syscall(fcntl64Syscall, uintptr(fd), uintptr(cmd), uintptr(arg))\n\tvar err error\n\tif errno != 0 {\n\t\terr = errno\n\t}\n\treturn int(valptr), err\n}\n\n// FcntlInt performs a fcntl syscall on fd with the provided command and argument.\nfunc FcntlInt(fd uintptr, cmd, arg int) (int, error) {\n\treturn fcntl(int(fd), cmd, arg)\n}\n\n// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.\nfunc FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {\n\t_, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))\n\tif errno == 0 {\n\t\treturn nil\n\t}\n\treturn errno\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fcntl_darwin.go",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage unix\n\nimport \"unsafe\"\n\n// FcntlInt performs a fcntl syscall on fd with the provided command and argument.\nfunc FcntlInt(fd uintptr, cmd, arg int) (int, error) {\n\treturn fcntl(int(fd), cmd, arg)\n}\n\n// FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.\nfunc FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {\n\t_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(lk))))\n\treturn err\n}\n\n// FcntlFstore performs a fcntl syscall for the F_PREALLOCATE command.\nfunc FcntlFstore(fd uintptr, cmd int, fstore *Fstore_t) error {\n\t_, err := fcntl(int(fd), cmd, int(uintptr(unsafe.Pointer(fstore))))\n\treturn err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go",
"content": "// Copyright 2014 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build (linux && 386) || (linux && arm) || (linux && mips) || (linux && mipsle) || (linux && ppc)\n\npackage unix\n\nfunc init() {\n\t// On 32-bit Linux systems, the fcntl syscall that matches Go's\n\t// Flock_t type is SYS_FCNTL64, not SYS_FCNTL.\n\tfcntl64Syscall = SYS_FCNTL64\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fdset.go",
"content": "// Copyright 2019 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris || zos\n\npackage unix\n\n// Set adds fd to the set fds.\nfunc (fds *FdSet) Set(fd int) {\n\tfds.Bits[fd/NFDBITS] |= (1 << (uintptr(fd) % NFDBITS))\n}\n\n// Clear removes fd from the set fds.\nfunc (fds *FdSet) Clear(fd int) {\n\tfds.Bits[fd/NFDBITS] &^= (1 << (uintptr(fd) % NFDBITS))\n}\n\n// IsSet returns whether fd is in the set fds.\nfunc (fds *FdSet) IsSet(fd int) bool {\n\treturn fds.Bits[fd/NFDBITS]&(1<<(uintptr(fd)%NFDBITS)) != 0\n}\n\n// Zero clears the set fds.\nfunc (fds *FdSet) Zero() {\n\tfor i := range fds.Bits {\n\t\tfds.Bits[i] = 0\n\t}\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/fstatfs_zos.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x\n\npackage unix\n\nimport (\n\t\"unsafe\"\n)\n\n// This file simulates fstatfs on z/OS using fstatvfs and w_getmntent.\n\nfunc Fstatfs(fd int, stat *Statfs_t) (err error) {\n\tvar stat_v Statvfs_t\n\terr = Fstatvfs(fd, &stat_v)\n\tif err == nil {\n\t\t// populate stat\n\t\tstat.Type = 0\n\t\tstat.Bsize = stat_v.Bsize\n\t\tstat.Blocks = stat_v.Blocks\n\t\tstat.Bfree = stat_v.Bfree\n\t\tstat.Bavail = stat_v.Bavail\n\t\tstat.Files = stat_v.Files\n\t\tstat.Ffree = stat_v.Ffree\n\t\tstat.Fsid = stat_v.Fsid\n\t\tstat.Namelen = stat_v.Namemax\n\t\tstat.Frsize = stat_v.Frsize\n\t\tstat.Flags = stat_v.Flag\n\t\tfor passn := 0; passn < 5; passn++ {\n\t\t\tswitch passn {\n\t\t\tcase 0:\n\t\t\t\terr = tryGetmntent64(stat)\n\t\t\t\tbreak\n\t\t\tcase 1:\n\t\t\t\terr = tryGetmntent128(stat)\n\t\t\t\tbreak\n\t\t\tcase 2:\n\t\t\t\terr = tryGetmntent256(stat)\n\t\t\t\tbreak\n\t\t\tcase 3:\n\t\t\t\terr = tryGetmntent512(stat)\n\t\t\t\tbreak\n\t\t\tcase 4:\n\t\t\t\terr = tryGetmntent1024(stat)\n\t\t\t\tbreak\n\t\t\tdefault:\n\t\t\t\tbreak\n\t\t\t}\n\t\t\t//proceed to return if: err is nil (found), err is nonnil but not ERANGE (another error occurred)\n\t\t\tif err == nil || err != nil && err != ERANGE {\n\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent64(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [64]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent128(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [128]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent256(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [256]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent512(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [512]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n\nfunc tryGetmntent1024(stat *Statfs_t) (err error) {\n\tvar mnt_ent_buffer struct {\n\t\theader W_Mnth\n\t\tfilesys_info [1024]W_Mntent\n\t}\n\tvar buffer_size int = int(unsafe.Sizeof(mnt_ent_buffer))\n\tfs_count, err := W_Getmntent((*byte)(unsafe.Pointer(&mnt_ent_buffer)), buffer_size)\n\tif err != nil {\n\t\treturn err\n\t}\n\terr = ERANGE //return ERANGE if no match is found in this batch\n\tfor i := 0; i < fs_count; i++ {\n\t\tif stat.Fsid == uint64(mnt_ent_buffer.filesys_info[i].Dev) {\n\t\t\tstat.Type = uint32(mnt_ent_buffer.filesys_info[i].Fstname[0])\n\t\t\terr = nil\n\t\t\tbreak\n\t\t}\n\t}\n\treturn err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/gccgo.go",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gccgo && !aix && !hurd\n\npackage unix\n\nimport \"syscall\"\n\n// We can't use the gc-syntax .s files for gccgo. On the plus side\n// much of the functionality can be written directly in Go.\n\nfunc realSyscallNoError(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r uintptr)\n\nfunc realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r, errno uintptr)\n\nfunc SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {\n\tsyscall.Entersyscall()\n\tr := realSyscallNoError(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)\n\tsyscall.Exitsyscall()\n\treturn r, 0\n}\n\nfunc Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tsyscall.Entersyscall()\n\tr, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)\n\tsyscall.Exitsyscall()\n\treturn r, 0, syscall.Errno(errno)\n}\n\nfunc Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tsyscall.Entersyscall()\n\tr, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)\n\tsyscall.Exitsyscall()\n\treturn r, 0, syscall.Errno(errno)\n}\n\nfunc Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tsyscall.Entersyscall()\n\tr, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9)\n\tsyscall.Exitsyscall()\n\treturn r, 0, syscall.Errno(errno)\n}\n\nfunc RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {\n\tr := realSyscallNoError(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)\n\treturn r, 0\n}\n\nfunc RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tr, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)\n\treturn r, 0, syscall.Errno(errno)\n}\n\nfunc RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {\n\tr, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)\n\treturn r, 0, syscall.Errno(errno)\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/gccgo_c.c",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gccgo && !aix && !hurd\n\n#include \n#include \n#include \n\n#define _STRINGIFY2_(x) #x\n#define _STRINGIFY_(x) _STRINGIFY2_(x)\n#define GOSYM_PREFIX _STRINGIFY_(__USER_LABEL_PREFIX__)\n\n// Call syscall from C code because the gccgo support for calling from\n// Go to C does not support varargs functions.\n\nstruct ret {\n\tuintptr_t r;\n\tuintptr_t err;\n};\n\nstruct ret gccgoRealSyscall(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)\n __asm__(GOSYM_PREFIX GOPKGPATH \".realSyscall\");\n\nstruct ret\ngccgoRealSyscall(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)\n{\n\tstruct ret r;\n\n\terrno = 0;\n\tr.r = syscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n\tr.err = errno;\n\treturn r;\n}\n\nuintptr_t gccgoRealSyscallNoError(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)\n __asm__(GOSYM_PREFIX GOPKGPATH \".realSyscallNoError\");\n\nuintptr_t\ngccgoRealSyscallNoError(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)\n{\n\treturn syscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9);\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go",
"content": "// Copyright 2015 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build gccgo && linux && amd64\n\npackage unix\n\nimport \"syscall\"\n\n//extern gettimeofday\nfunc realGettimeofday(*Timeval, *byte) int32\n\nfunc gettimeofday(tv *Timeval) (err syscall.Errno) {\n\tr := realGettimeofday(tv, nil)\n\tif r < 0 {\n\t\treturn syscall.GetErrno()\n\t}\n\treturn 0\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ifreq_linux.go",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build linux\n\npackage unix\n\nimport (\n\t\"unsafe\"\n)\n\n// Helpers for dealing with ifreq since it contains a union and thus requires a\n// lot of unsafe.Pointer casts to use properly.\n\n// An Ifreq is a type-safe wrapper around the raw ifreq struct. An Ifreq\n// contains an interface name and a union of arbitrary data which can be\n// accessed using the Ifreq's methods. To create an Ifreq, use the NewIfreq\n// function.\n//\n// Use the Name method to access the stored interface name. The union data\n// fields can be get and set using the following methods:\n// - Uint16/SetUint16: flags\n// - Uint32/SetUint32: ifindex, metric, mtu\ntype Ifreq struct{ raw ifreq }\n\n// NewIfreq creates an Ifreq with the input network interface name after\n// validating the name does not exceed IFNAMSIZ-1 (trailing NULL required)\n// bytes.\nfunc NewIfreq(name string) (*Ifreq, error) {\n\t// Leave room for terminating NULL byte.\n\tif len(name) >= IFNAMSIZ {\n\t\treturn nil, EINVAL\n\t}\n\n\tvar ifr ifreq\n\tcopy(ifr.Ifrn[:], name)\n\n\treturn &Ifreq{raw: ifr}, nil\n}\n\n// TODO(mdlayher): get/set methods for hardware address sockaddr, char array, etc.\n\n// Name returns the interface name associated with the Ifreq.\nfunc (ifr *Ifreq) Name() string {\n\treturn ByteSliceToString(ifr.raw.Ifrn[:])\n}\n\n// According to netdevice(7), only AF_INET addresses are returned for numerous\n// sockaddr ioctls. For convenience, we expose these as Inet4Addr since the Port\n// field and other data is always empty.\n\n// Inet4Addr returns the Ifreq union data from an embedded sockaddr as a C\n// in_addr/Go []byte (4-byte IPv4 address) value. If the sockaddr family is not\n// AF_INET, an error is returned.\nfunc (ifr *Ifreq) Inet4Addr() ([]byte, error) {\n\traw := *(*RawSockaddrInet4)(unsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]))\n\tif raw.Family != AF_INET {\n\t\t// Cannot safely interpret raw.Addr bytes as an IPv4 address.\n\t\treturn nil, EINVAL\n\t}\n\n\treturn raw.Addr[:], nil\n}\n\n// SetInet4Addr sets a C in_addr/Go []byte (4-byte IPv4 address) value in an\n// embedded sockaddr within the Ifreq's union data. v must be 4 bytes in length\n// or an error will be returned.\nfunc (ifr *Ifreq) SetInet4Addr(v []byte) error {\n\tif len(v) != 4 {\n\t\treturn EINVAL\n\t}\n\n\tvar addr [4]byte\n\tcopy(addr[:], v)\n\n\tifr.clear()\n\t*(*RawSockaddrInet4)(\n\t\tunsafe.Pointer(&ifr.raw.Ifru[:SizeofSockaddrInet4][0]),\n\t) = RawSockaddrInet4{\n\t\t// Always set IP family as ioctls would require it anyway.\n\t\tFamily: AF_INET,\n\t\tAddr: addr,\n\t}\n\n\treturn nil\n}\n\n// Uint16 returns the Ifreq union data as a C short/Go uint16 value.\nfunc (ifr *Ifreq) Uint16() uint16 {\n\treturn *(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0]))\n}\n\n// SetUint16 sets a C short/Go uint16 value as the Ifreq's union data.\nfunc (ifr *Ifreq) SetUint16(v uint16) {\n\tifr.clear()\n\t*(*uint16)(unsafe.Pointer(&ifr.raw.Ifru[:2][0])) = v\n}\n\n// Uint32 returns the Ifreq union data as a C int/Go uint32 value.\nfunc (ifr *Ifreq) Uint32() uint32 {\n\treturn *(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0]))\n}\n\n// SetUint32 sets a C int/Go uint32 value as the Ifreq's union data.\nfunc (ifr *Ifreq) SetUint32(v uint32) {\n\tifr.clear()\n\t*(*uint32)(unsafe.Pointer(&ifr.raw.Ifru[:4][0])) = v\n}\n\n// clear zeroes the ifreq's union field to prevent trailing garbage data from\n// being sent to the kernel if an ifreq is reused.\nfunc (ifr *Ifreq) clear() {\n\tfor i := range ifr.raw.Ifru {\n\t\tifr.raw.Ifru[i] = 0\n\t}\n}\n\n// TODO(mdlayher): export as IfreqData? For now we can provide helpers such as\n// IoctlGetEthtoolDrvinfo which use these APIs under the hood.\n\n// An ifreqData is an Ifreq which carries pointer data. To produce an ifreqData,\n// use the Ifreq.withData method.\ntype ifreqData struct {\n\tname [IFNAMSIZ]byte\n\t// A type separate from ifreq is required in order to comply with the\n\t// unsafe.Pointer rules since the \"pointer-ness\" of data would not be\n\t// preserved if it were cast into the byte array of a raw ifreq.\n\tdata unsafe.Pointer\n\t// Pad to the same size as ifreq.\n\t_ [len(ifreq{}.Ifru) - SizeofPtr]byte\n}\n\n// withData produces an ifreqData with the pointer p set for ioctls which require\n// arbitrary pointer data.\nfunc (ifr Ifreq) withData(p unsafe.Pointer) ifreqData {\n\treturn ifreqData{\n\t\tname: ifr.raw.Ifrn,\n\t\tdata: p,\n\t}\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ioctl_linux.go",
"content": "// Copyright 2021 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\npackage unix\n\nimport \"unsafe\"\n\n// IoctlRetInt performs an ioctl operation specified by req on a device\n// associated with opened file descriptor fd, and returns a non-negative\n// integer that is returned by the ioctl syscall.\nfunc IoctlRetInt(fd int, req uint) (int, error) {\n\tret, _, err := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), 0)\n\tif err != 0 {\n\t\treturn 0, err\n\t}\n\treturn int(ret), nil\n}\n\nfunc IoctlGetUint32(fd int, req uint) (uint32, error) {\n\tvar value uint32\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn value, err\n}\n\nfunc IoctlGetRTCTime(fd int) (*RTCTime, error) {\n\tvar value RTCTime\n\terr := ioctlPtr(fd, RTC_RD_TIME, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\nfunc IoctlSetRTCTime(fd int, value *RTCTime) error {\n\treturn ioctlPtr(fd, RTC_SET_TIME, unsafe.Pointer(value))\n}\n\nfunc IoctlGetRTCWkAlrm(fd int) (*RTCWkAlrm, error) {\n\tvar value RTCWkAlrm\n\terr := ioctlPtr(fd, RTC_WKALM_RD, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\nfunc IoctlSetRTCWkAlrm(fd int, value *RTCWkAlrm) error {\n\treturn ioctlPtr(fd, RTC_WKALM_SET, unsafe.Pointer(value))\n}\n\n// IoctlGetEthtoolDrvinfo fetches ethtool driver information for the network\n// device specified by ifname.\nfunc IoctlGetEthtoolDrvinfo(fd int, ifname string) (*EthtoolDrvinfo, error) {\n\tifr, err := NewIfreq(ifname)\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tvalue := EthtoolDrvinfo{Cmd: ETHTOOL_GDRVINFO}\n\tifrd := ifr.withData(unsafe.Pointer(&value))\n\n\terr = ioctlIfreqData(fd, SIOCETHTOOL, &ifrd)\n\treturn &value, err\n}\n\n// IoctlGetWatchdogInfo fetches information about a watchdog device from the\n// Linux watchdog API. For more information, see:\n// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.\nfunc IoctlGetWatchdogInfo(fd int) (*WatchdogInfo, error) {\n\tvar value WatchdogInfo\n\terr := ioctlPtr(fd, WDIOC_GETSUPPORT, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\n// IoctlWatchdogKeepalive issues a keepalive ioctl to a watchdog device. For\n// more information, see:\n// https://www.kernel.org/doc/html/latest/watchdog/watchdog-api.html.\nfunc IoctlWatchdogKeepalive(fd int) error {\n\t// arg is ignored and not a pointer, so ioctl is fine instead of ioctlPtr.\n\treturn ioctl(fd, WDIOC_KEEPALIVE, 0)\n}\n\n// IoctlFileCloneRange performs an FICLONERANGE ioctl operation to clone the\n// range of data conveyed in value to the file associated with the file\n// descriptor destFd. See the ioctl_ficlonerange(2) man page for details.\nfunc IoctlFileCloneRange(destFd int, value *FileCloneRange) error {\n\treturn ioctlPtr(destFd, FICLONERANGE, unsafe.Pointer(value))\n}\n\n// IoctlFileClone performs an FICLONE ioctl operation to clone the entire file\n// associated with the file description srcFd to the file associated with the\n// file descriptor destFd. See the ioctl_ficlone(2) man page for details.\nfunc IoctlFileClone(destFd, srcFd int) error {\n\treturn ioctl(destFd, FICLONE, uintptr(srcFd))\n}\n\ntype FileDedupeRange struct {\n\tSrc_offset uint64\n\tSrc_length uint64\n\tReserved1 uint16\n\tReserved2 uint32\n\tInfo []FileDedupeRangeInfo\n}\n\ntype FileDedupeRangeInfo struct {\n\tDest_fd int64\n\tDest_offset uint64\n\tBytes_deduped uint64\n\tStatus int32\n\tReserved uint32\n}\n\n// IoctlFileDedupeRange performs an FIDEDUPERANGE ioctl operation to share the\n// range of data conveyed in value from the file associated with the file\n// descriptor srcFd to the value.Info destinations. See the\n// ioctl_fideduperange(2) man page for details.\nfunc IoctlFileDedupeRange(srcFd int, value *FileDedupeRange) error {\n\tbuf := make([]byte, SizeofRawFileDedupeRange+\n\t\tlen(value.Info)*SizeofRawFileDedupeRangeInfo)\n\trawrange := (*RawFileDedupeRange)(unsafe.Pointer(&buf[0]))\n\trawrange.Src_offset = value.Src_offset\n\trawrange.Src_length = value.Src_length\n\trawrange.Dest_count = uint16(len(value.Info))\n\trawrange.Reserved1 = value.Reserved1\n\trawrange.Reserved2 = value.Reserved2\n\n\tfor i := range value.Info {\n\t\trawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(\n\t\t\tuintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +\n\t\t\t\tuintptr(i*SizeofRawFileDedupeRangeInfo)))\n\t\trawinfo.Dest_fd = value.Info[i].Dest_fd\n\t\trawinfo.Dest_offset = value.Info[i].Dest_offset\n\t\trawinfo.Bytes_deduped = value.Info[i].Bytes_deduped\n\t\trawinfo.Status = value.Info[i].Status\n\t\trawinfo.Reserved = value.Info[i].Reserved\n\t}\n\n\terr := ioctlPtr(srcFd, FIDEDUPERANGE, unsafe.Pointer(&buf[0]))\n\n\t// Output\n\tfor i := range value.Info {\n\t\trawinfo := (*RawFileDedupeRangeInfo)(unsafe.Pointer(\n\t\t\tuintptr(unsafe.Pointer(&buf[0])) + uintptr(SizeofRawFileDedupeRange) +\n\t\t\t\tuintptr(i*SizeofRawFileDedupeRangeInfo)))\n\t\tvalue.Info[i].Dest_fd = rawinfo.Dest_fd\n\t\tvalue.Info[i].Dest_offset = rawinfo.Dest_offset\n\t\tvalue.Info[i].Bytes_deduped = rawinfo.Bytes_deduped\n\t\tvalue.Info[i].Status = rawinfo.Status\n\t\tvalue.Info[i].Reserved = rawinfo.Reserved\n\t}\n\n\treturn err\n}\n\nfunc IoctlHIDGetDesc(fd int, value *HIDRawReportDescriptor) error {\n\treturn ioctlPtr(fd, HIDIOCGRDESC, unsafe.Pointer(value))\n}\n\nfunc IoctlHIDGetRawInfo(fd int) (*HIDRawDevInfo, error) {\n\tvar value HIDRawDevInfo\n\terr := ioctlPtr(fd, HIDIOCGRAWINFO, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\nfunc IoctlHIDGetRawName(fd int) (string, error) {\n\tvar value [_HIDIOCGRAWNAME_LEN]byte\n\terr := ioctlPtr(fd, _HIDIOCGRAWNAME, unsafe.Pointer(&value[0]))\n\treturn ByteSliceToString(value[:]), err\n}\n\nfunc IoctlHIDGetRawPhys(fd int) (string, error) {\n\tvar value [_HIDIOCGRAWPHYS_LEN]byte\n\terr := ioctlPtr(fd, _HIDIOCGRAWPHYS, unsafe.Pointer(&value[0]))\n\treturn ByteSliceToString(value[:]), err\n}\n\nfunc IoctlHIDGetRawUniq(fd int) (string, error) {\n\tvar value [_HIDIOCGRAWUNIQ_LEN]byte\n\terr := ioctlPtr(fd, _HIDIOCGRAWUNIQ, unsafe.Pointer(&value[0]))\n\treturn ByteSliceToString(value[:]), err\n}\n\n// IoctlIfreq performs an ioctl using an Ifreq structure for input and/or\n// output. See the netdevice(7) man page for details.\nfunc IoctlIfreq(fd int, req uint, value *Ifreq) error {\n\t// It is possible we will add more fields to *Ifreq itself later to prevent\n\t// misuse, so pass the raw *ifreq directly.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(&value.raw))\n}\n\n// TODO(mdlayher): export if and when IfreqData is exported.\n\n// ioctlIfreqData performs an ioctl using an ifreqData structure for input\n// and/or output. See the netdevice(7) man page for details.\nfunc ioctlIfreqData(fd int, req uint, value *ifreqData) error {\n\t// The memory layout of IfreqData (type-safe) and ifreq (not type-safe) are\n\t// identical so pass *IfreqData directly.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(value))\n}\n\n// IoctlKCMClone attaches a new file descriptor to a multiplexor by cloning an\n// existing KCM socket, returning a structure containing the file descriptor of\n// the new socket.\nfunc IoctlKCMClone(fd int) (*KCMClone, error) {\n\tvar info KCMClone\n\tif err := ioctlPtr(fd, SIOCKCMCLONE, unsafe.Pointer(&info)); err != nil {\n\t\treturn nil, err\n\t}\n\n\treturn &info, nil\n}\n\n// IoctlKCMAttach attaches a TCP socket and associated BPF program file\n// descriptor to a multiplexor.\nfunc IoctlKCMAttach(fd int, info KCMAttach) error {\n\treturn ioctlPtr(fd, SIOCKCMATTACH, unsafe.Pointer(&info))\n}\n\n// IoctlKCMUnattach unattaches a TCP socket file descriptor from a multiplexor.\nfunc IoctlKCMUnattach(fd int, info KCMUnattach) error {\n\treturn ioctlPtr(fd, SIOCKCMUNATTACH, unsafe.Pointer(&info))\n}\n\n// IoctlLoopGetStatus64 gets the status of the loop device associated with the\n// file descriptor fd using the LOOP_GET_STATUS64 operation.\nfunc IoctlLoopGetStatus64(fd int) (*LoopInfo64, error) {\n\tvar value LoopInfo64\n\tif err := ioctlPtr(fd, LOOP_GET_STATUS64, unsafe.Pointer(&value)); err != nil {\n\t\treturn nil, err\n\t}\n\treturn &value, nil\n}\n\n// IoctlLoopSetStatus64 sets the status of the loop device associated with the\n// file descriptor fd using the LOOP_SET_STATUS64 operation.\nfunc IoctlLoopSetStatus64(fd int, value *LoopInfo64) error {\n\treturn ioctlPtr(fd, LOOP_SET_STATUS64, unsafe.Pointer(value))\n}\n\n// IoctlLoopConfigure configures all loop device parameters in a single step\nfunc IoctlLoopConfigure(fd int, value *LoopConfig) error {\n\treturn ioctlPtr(fd, LOOP_CONFIGURE, unsafe.Pointer(value))\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ioctl_signed.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build aix || solaris\n\npackage unix\n\nimport (\n\t\"unsafe\"\n)\n\n// ioctl itself should not be exposed directly, but additional get/set\n// functions for specific types are permissible.\n\n// IoctlSetInt performs an ioctl operation which sets an integer value\n// on fd, using the specified request number.\nfunc IoctlSetInt(fd int, req int, value int) error {\n\treturn ioctl(fd, req, uintptr(value))\n}\n\n// IoctlSetPointerInt performs an ioctl operation which sets an\n// integer value on fd, using the specified request number. The ioctl\n// argument is called with a pointer to the integer value, rather than\n// passing the integer value directly.\nfunc IoctlSetPointerInt(fd int, req int, value int) error {\n\tv := int32(value)\n\treturn ioctlPtr(fd, req, unsafe.Pointer(&v))\n}\n\n// IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.\n//\n// To change fd's window size, the req argument should be TIOCSWINSZ.\nfunc IoctlSetWinsize(fd int, req int, value *Winsize) error {\n\t// TODO: if we get the chance, remove the req parameter and\n\t// hardcode TIOCSWINSZ.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(value))\n}\n\n// IoctlSetTermios performs an ioctl on fd with a *Termios.\n//\n// The req value will usually be TCSETA or TIOCSETA.\nfunc IoctlSetTermios(fd int, req int, value *Termios) error {\n\t// TODO: if we get the chance, remove the req parameter.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(value))\n}\n\n// IoctlGetInt performs an ioctl operation which gets an integer value\n// from fd, using the specified request number.\n//\n// A few ioctl requests use the return value as an output parameter;\n// for those, IoctlRetInt should be used instead of this function.\nfunc IoctlGetInt(fd int, req int) (int, error) {\n\tvar value int\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn value, err\n}\n\nfunc IoctlGetWinsize(fd int, req int) (*Winsize, error) {\n\tvar value Winsize\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\nfunc IoctlGetTermios(fd int, req int) (*Termios, error) {\n\tvar value Termios\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn &value, err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ioctl_unsigned.go",
"content": "// Copyright 2018 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build darwin || dragonfly || freebsd || hurd || linux || netbsd || openbsd\n\npackage unix\n\nimport (\n\t\"unsafe\"\n)\n\n// ioctl itself should not be exposed directly, but additional get/set\n// functions for specific types are permissible.\n\n// IoctlSetInt performs an ioctl operation which sets an integer value\n// on fd, using the specified request number.\nfunc IoctlSetInt(fd int, req uint, value int) error {\n\treturn ioctl(fd, req, uintptr(value))\n}\n\n// IoctlSetPointerInt performs an ioctl operation which sets an\n// integer value on fd, using the specified request number. The ioctl\n// argument is called with a pointer to the integer value, rather than\n// passing the integer value directly.\nfunc IoctlSetPointerInt(fd int, req uint, value int) error {\n\tv := int32(value)\n\treturn ioctlPtr(fd, req, unsafe.Pointer(&v))\n}\n\n// IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.\n//\n// To change fd's window size, the req argument should be TIOCSWINSZ.\nfunc IoctlSetWinsize(fd int, req uint, value *Winsize) error {\n\t// TODO: if we get the chance, remove the req parameter and\n\t// hardcode TIOCSWINSZ.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(value))\n}\n\n// IoctlSetTermios performs an ioctl on fd with a *Termios.\n//\n// The req value will usually be TCSETA or TIOCSETA.\nfunc IoctlSetTermios(fd int, req uint, value *Termios) error {\n\t// TODO: if we get the chance, remove the req parameter.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(value))\n}\n\n// IoctlGetInt performs an ioctl operation which gets an integer value\n// from fd, using the specified request number.\n//\n// A few ioctl requests use the return value as an output parameter;\n// for those, IoctlRetInt should be used instead of this function.\nfunc IoctlGetInt(fd int, req uint) (int, error) {\n\tvar value int\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn value, err\n}\n\nfunc IoctlGetWinsize(fd int, req uint) (*Winsize, error) {\n\tvar value Winsize\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\nfunc IoctlGetTermios(fd int, req uint) (*Termios, error) {\n\tvar value Termios\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn &value, err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/ioctl_zos.go",
"content": "// Copyright 2020 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license that can be found in the LICENSE file.\n\n//go:build zos && s390x\n\npackage unix\n\nimport (\n\t\"runtime\"\n\t\"unsafe\"\n)\n\n// ioctl itself should not be exposed directly, but additional get/set\n// functions for specific types are permissible.\n\n// IoctlSetInt performs an ioctl operation which sets an integer value\n// on fd, using the specified request number.\nfunc IoctlSetInt(fd int, req int, value int) error {\n\treturn ioctl(fd, req, uintptr(value))\n}\n\n// IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.\n//\n// To change fd's window size, the req argument should be TIOCSWINSZ.\nfunc IoctlSetWinsize(fd int, req int, value *Winsize) error {\n\t// TODO: if we get the chance, remove the req parameter and\n\t// hardcode TIOCSWINSZ.\n\treturn ioctlPtr(fd, req, unsafe.Pointer(value))\n}\n\n// IoctlSetTermios performs an ioctl on fd with a *Termios.\n//\n// The req value is expected to be TCSETS, TCSETSW, or TCSETSF\nfunc IoctlSetTermios(fd int, req int, value *Termios) error {\n\tif (req != TCSETS) && (req != TCSETSW) && (req != TCSETSF) {\n\t\treturn ENOSYS\n\t}\n\terr := Tcsetattr(fd, int(req), value)\n\truntime.KeepAlive(value)\n\treturn err\n}\n\n// IoctlGetInt performs an ioctl operation which gets an integer value\n// from fd, using the specified request number.\n//\n// A few ioctl requests use the return value as an output parameter;\n// for those, IoctlRetInt should be used instead of this function.\nfunc IoctlGetInt(fd int, req int) (int, error) {\n\tvar value int\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn value, err\n}\n\nfunc IoctlGetWinsize(fd int, req int) (*Winsize, error) {\n\tvar value Winsize\n\terr := ioctlPtr(fd, req, unsafe.Pointer(&value))\n\treturn &value, err\n}\n\n// IoctlGetTermios performs an ioctl on fd with a *Termios.\n//\n// The req value is expected to be TCGETS\nfunc IoctlGetTermios(fd int, req int) (*Termios, error) {\n\tvar value Termios\n\tif req != TCGETS {\n\t\treturn &value, ENOSYS\n\t}\n\terr := Tcgetattr(fd, &value)\n\treturn &value, err\n}\n"
},
{
"path": "vendor/golang.org/x/sys/unix/mkall.sh",
"content": "#!/usr/bin/env bash\n# Copyright 2009 The Go Authors. All rights reserved.\n# Use of this source code is governed by a BSD-style\n# license that can be found in the LICENSE file.\n\n# This script runs or (given -n) prints suggested commands to generate files for\n# the Architecture/OS specified by the GOARCH and GOOS environment variables.\n# See README.md for more information about how the build system works.\n\nGOOSARCH=\"${GOOS}_${GOARCH}\"\n\n# defaults\nmksyscall=\"go run mksyscall.go\"\nmkerrors=\"./mkerrors.sh\"\nzerrors=\"zerrors_$GOOSARCH.go\"\nmksysctl=\"\"\nzsysctl=\"zsysctl_$GOOSARCH.go\"\nmksysnum=\nmktypes=\nmkasm=\nrun=\"sh\"\ncmd=\"\"\n\ncase \"$1\" in\n-syscalls)\n\tfor i in zsyscall*go\n\tdo\n\t\t# Run the command line that appears in the first line\n\t\t# of the generated file to regenerate it.\n\t\tsed 1q $i | sed 's;^// ;;' | sh > _$i && gofmt < _$i > $i\n\t\trm _$i\n\tdone\n\texit 0\n\t;;\n-n)\n\trun=\"cat\"\n\tcmd=\"echo\"\n\tshift\nesac\n\ncase \"$#\" in\n0)\n\t;;\n*)\n\techo 'usage: mkall.sh [-n]' 1>&2\n\texit 2\nesac\n\nif [[ \"$GOOS\" = \"linux\" ]]; then\n\t# Use the Docker-based build system\n\t# Files generated through docker (use $cmd so you can Ctl-C the build or run)\n\t$cmd docker build --tag generate:$GOOS $GOOS\n\t$cmd docker run --interactive --tty --volume $(cd -- \"$(dirname -- \"$0\")/..\" && pwd):/build generate:$GOOS\n\texit\nfi\n\nGOOSARCH_in=syscall_$GOOSARCH.go\ncase \"$GOOSARCH\" in\n_* | *_ | _)\n\techo 'undefined $GOOS_$GOARCH:' \"$GOOSARCH\" 1>&2\n\texit 1\n\t;;\naix_ppc)\n\tmkerrors=\"$mkerrors -maix32\"\n\tmksyscall=\"go run mksyscall_aix_ppc.go -aix\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\naix_ppc64)\n\tmkerrors=\"$mkerrors -maix64\"\n\tmksyscall=\"go run mksyscall_aix_ppc64.go -aix\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\ndarwin_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\tmkasm=\"go run mkasm.go\"\n\t;;\ndarwin_arm64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\tmkasm=\"go run mkasm.go\"\n\t;;\ndragonfly_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -dragonfly\"\n\tmksysnum=\"go run mksysnum.go 'https://gitweb.dragonflybsd.org/dragonfly.git/blob_plain/HEAD:/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nfreebsd_386)\n\tmkerrors=\"$mkerrors -m32\"\n\tmksyscall=\"go run mksyscall.go -l32\"\n\tmksysnum=\"go run mksysnum.go 'https://cgit.freebsd.org/src/plain/sys/kern/syscalls.master?h=stable/12'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nfreebsd_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksysnum=\"go run mksysnum.go 'https://cgit.freebsd.org/src/plain/sys/kern/syscalls.master?h=stable/12'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nfreebsd_arm)\n\tmkerrors=\"$mkerrors\"\n\tmksyscall=\"go run mksyscall.go -l32 -arm\"\n\tmksysnum=\"go run mksysnum.go 'https://cgit.freebsd.org/src/plain/sys/kern/syscalls.master?h=stable/12'\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nfreebsd_arm64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksysnum=\"go run mksysnum.go 'https://cgit.freebsd.org/src/plain/sys/kern/syscalls.master?h=stable/12'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nfreebsd_riscv64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksysnum=\"go run mksysnum.go 'https://cgit.freebsd.org/src/plain/sys/kern/syscalls.master?h=stable/12'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nnetbsd_386)\n\tmkerrors=\"$mkerrors -m32\"\n\tmksyscall=\"go run mksyscall.go -l32 -netbsd\"\n\tmksysnum=\"go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nnetbsd_amd64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -netbsd\"\n\tmksysnum=\"go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nnetbsd_arm)\n\tmkerrors=\"$mkerrors\"\n\tmksyscall=\"go run mksyscall.go -l32 -netbsd -arm\"\n\tmksysnum=\"go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nnetbsd_arm64)\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -netbsd\"\n\tmksysnum=\"go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nopenbsd_386)\n\tmkasm=\"go run mkasm.go\"\n\tmkerrors=\"$mkerrors -m32\"\n\tmksyscall=\"go run mksyscall.go -l32 -openbsd -libc\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nopenbsd_amd64)\n\tmkasm=\"go run mkasm.go\"\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -openbsd -libc\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nopenbsd_arm)\n\tmkasm=\"go run mkasm.go\"\n\tmkerrors=\"$mkerrors\"\n\tmksyscall=\"go run mksyscall.go -l32 -openbsd -arm -libc\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nopenbsd_arm64)\n\tmkasm=\"go run mkasm.go\"\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -openbsd -libc\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nopenbsd_mips64)\n\tmkasm=\"go run mkasm.go\"\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -openbsd -libc\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nopenbsd_ppc64)\n\tmkasm=\"go run mkasm.go\"\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -openbsd -libc\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nopenbsd_riscv64)\n\tmkasm=\"go run mkasm.go\"\n\tmkerrors=\"$mkerrors -m64\"\n\tmksyscall=\"go run mksyscall.go -openbsd -libc\"\n\tmksysctl=\"go run mksysctl_openbsd.go\"\n\t# Let the type of C char be signed for making the bare syscall\n\t# API consistent across platforms.\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char\"\n\t;;\nsolaris_amd64)\n\tmksyscall=\"go run mksyscall_solaris.go\"\n\tmkerrors=\"$mkerrors -m64\"\n\tmksysnum=\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\nillumos_amd64)\n mksyscall=\"go run mksyscall_solaris.go\"\n\tmkerrors=\n\tmksysnum=\n\tmktypes=\"GOARCH=$GOARCH go tool cgo -godefs\"\n\t;;\n*)\n\techo 'unrecognized $GOOS_$GOARCH: ' \"$GOOSARCH\" 1>&2\n\texit 1\n\t;;\nesac\n\n(\n\tif [ -n \"$mkerrors\" ]; then echo \"$mkerrors |gofmt >$zerrors\"; fi\n\tcase \"$GOOS\" in\n\t*)\n\t\tsyscall_goos=\"syscall_$GOOS.go\"\n\t\tcase \"$GOOS\" in\n\t\tdarwin | dragonfly | freebsd | netbsd | openbsd)\n\t\t\tsyscall_goos=\"syscall_bsd.go $syscall_goos\"\n\t\t\t;;\n\t\tesac\n\t\tif [ -n \"$mksyscall\" ]; then\n\t\t\tif [ \"$GOOSARCH\" == \"aix_ppc64\" ]; then\n\t\t\t\t# aix/ppc64 script generates files instead of writing to stdin.\n\t\t\t\techo \"$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in && gofmt -w zsyscall_$GOOSARCH.go && gofmt -w zsyscall_\"$GOOSARCH\"_gccgo.go && gofmt -w zsyscall_\"$GOOSARCH\"_gc.go \" ;\n\t\t\telif [ \"$GOOS\" == \"illumos\" ]; then\n\t\t\t # illumos code generation requires a --illumos switch\n\t\t\t echo \"$mksyscall -illumos -tags illumos,$GOARCH syscall_illumos.go |gofmt > zsyscall_illumos_$GOARCH.go\";\n\t\t\t # illumos implies solaris, so solaris code generation is also required\n\t\t\t\techo \"$mksyscall -tags solaris,$GOARCH syscall_solaris.go syscall_solaris_$GOARCH.go |gofmt >zsyscall_solaris_$GOARCH.go\";\n\t\t\telse\n\t\t\t\techo \"$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in |gofmt >zsyscall_$GOOSARCH.go\";\n\t\t\tfi\n\t\tfi\n\tesac\n\tif [ -n \"$mksysctl\" ]; then echo \"$mksysctl |gofmt >$zsysctl\"; fi\n\tif [ -n \"$mksysnum\" ]; then echo \"$mksysnum |gofmt >zsysnum_$GOOSARCH.go\"; fi\n\tif [ -n \"$mktypes\" ]; then echo \"$mktypes types_$GOOS.go | go run mkpost.go > ztypes_$GOOSARCH.go\"; fi\n\tif [ -n \"$mkasm\" ]; then echo \"$mkasm $GOOS $GOARCH\"; fi\n) | $run\n"
},
{
"path": "vendor/golang.org/x/sys/unix/mkerrors.sh",
"content": "#!/usr/bin/env bash\n# Copyright 2009 The Go Authors. All rights reserved.\n# Use of this source code is governed by a BSD-style\n# license that can be found in the LICENSE file.\n\n# Generate Go code listing errors and other #defined constant\n# values (ENAMETOOLONG etc.), by asking the preprocessor\n# about the definitions.\n\nunset LANG\nexport LC_ALL=C\nexport LC_CTYPE=C\n\nif test -z \"$GOARCH\" -o -z \"$GOOS\"; then\n\techo 1>&2 \"GOARCH or GOOS not defined in environment\"\n\texit 1\nfi\n\n# Check that we are using the new build system if we should\nif [[ \"$GOOS\" = \"linux\" ]] && [[ \"$GOLANG_SYS_BUILD\" != \"docker\" ]]; then\n\techo 1>&2 \"In the Docker based build system, mkerrors should not be called directly.\"\n\techo 1>&2 \"See README.md\"\n\texit 1\nfi\n\nif [[ \"$GOOS\" = \"aix\" ]]; then\n\tCC=${CC:-gcc}\nelse\n\tCC=${CC:-cc}\nfi\n\nif [[ \"$GOOS\" = \"solaris\" ]]; then\n\t# Assumes GNU versions of utilities in PATH.\n\texport PATH=/usr/gnu/bin:$PATH\nfi\n\nuname=$(uname)\n\nincludes_AIX='\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define AF_LOCAL AF_UNIX\n'\n\nincludes_Darwin='\n#define _DARWIN_C_SOURCE\n#define KERNEL 1\n#define _DARWIN_USE_64_BIT_INODE\n#define __APPLE_USE_RFC_3542\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// for backwards compatibility because moved TIOCREMOTE to Kernel.framework after MacOSX12.0.sdk.\n#define TIOCREMOTE 0x80047469\n'\n\nincludes_DragonFly='\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n'\n\nincludes_FreeBSD='\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#if __FreeBSD__ >= 10\n#define IFT_CARP\t0xf8\t// IFT_CARP is deprecated in FreeBSD 10\n#undef SIOCAIFADDR\n#define SIOCAIFADDR\t_IOW(105, 26, struct oifaliasreq)\t// ifaliasreq contains if_data\n#undef SIOCSIFPHYADDR\n#define SIOCSIFPHYADDR\t_IOW(105, 70, struct oifaliasreq)\t// ifaliasreq contains if_data\n#endif\n'\n\nincludes_Linux='\n#define _LARGEFILE_SOURCE\n#define _LARGEFILE64_SOURCE\n#ifndef __LP64__\n#define _FILE_OFFSET_BITS 64\n#endif\n#define _GNU_SOURCE\n\n// is broken on powerpc64, as it fails to include definitions of\n// these structures. We just include them copied from .\n#if defined(__powerpc__)\nstruct sgttyb {\n char sg_ispeed;\n char sg_ospeed;\n char sg_erase;\n char sg_kill;\n short sg_flags;\n};\n\nstruct tchars {\n char t_intrc;\n char t_quitc;\n char t_startc;\n char t_stopc;\n char t_eofc;\n char t_brkc;\n};\n\nstruct ltchars {\n char t_suspc;\n char t_dsuspc;\n char t_rprntc;\n char t_flushc;\n char t_werasc;\n char t_lnextc;\n};\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#if defined(__sparc__)\n// On sparc{,64}, the kernel defines struct termios2 itself which clashes with the\n// definition in glibc. As only the error constants are needed here, include the\n// generic termibits.h (which is included by termbits.h on sparc).\n#include \n#else\n#include \n#endif\n\n#ifndef PTRACE_GETREGS\n#define PTRACE_GETREGS\t0xc\n#endif\n\n#ifndef PTRACE_SETREGS\n#define PTRACE_SETREGS\t0xd\n#endif\n\n#ifdef SOL_BLUETOOTH\n// SPARC includes this in /usr/include/sparc64-linux-gnu/bits/socket.h\n// but it is already in bluetooth_linux.go\n#undef SOL_BLUETOOTH\n#endif\n\n// Certain constants are missing from the fs/crypto UAPI\n#define FS_KEY_DESC_PREFIX \"fscrypt:\"\n#define FS_KEY_DESC_PREFIX_SIZE 8\n#define FS_MAX_KEY_SIZE 64\n\n// The code generator produces -0x1 for (~0), but an unsigned value is necessary\n// for the tipc_subscr timeout __u32 field.\n#undef TIPC_WAIT_FOREVER\n#define TIPC_WAIT_FOREVER 0xffffffff\n\n// Copied from linux/netfilter/nf_nat.h\n// Including linux/netfilter/nf_nat.h here causes conflicts between linux/in.h\n// and netinet/in.h.\n#define NF_NAT_RANGE_MAP_IPS\t\t\t(1 << 0)\n#define NF_NAT_RANGE_PROTO_SPECIFIED\t\t(1 << 1)\n#define NF_NAT_RANGE_PROTO_RANDOM\t\t(1 << 2)\n#define NF_NAT_RANGE_PERSISTENT\t\t\t(1 << 3)\n#define NF_NAT_RANGE_PROTO_RANDOM_FULLY\t\t(1 << 4)\n#define NF_NAT_RANGE_PROTO_OFFSET\t\t(1 << 5)\n#define NF_NAT_RANGE_NETMAP\t\t\t(1 << 6)\n#define NF_NAT_RANGE_PROTO_RANDOM_ALL\t\t\\\n\t(NF_NAT_RANGE_PROTO_RANDOM | NF_NAT_RANGE_PROTO_RANDOM_FULLY)\n#define NF_NAT_RANGE_MASK\t\t\t\t\t\\\n\t(NF_NAT_RANGE_MAP_IPS | NF_NAT_RANGE_PROTO_SPECIFIED |\t\\\n\t NF_NAT_RANGE_PROTO_RANDOM | NF_NAT_RANGE_PERSISTENT |\t\\\n\t NF_NAT_RANGE_PROTO_RANDOM_FULLY | NF_NAT_RANGE_PROTO_OFFSET | \\\n\t NF_NAT_RANGE_NETMAP)\n\n// Copied from linux/hid.h.\n// Keep in sync with the size of the referenced fields.\n#define _HIDIOCGRAWNAME_LEN\t128 // sizeof_field(struct hid_device, name)\n#define _HIDIOCGRAWPHYS_LEN\t64 // sizeof_field(struct hid_device, phys)\n#define _HIDIOCGRAWUNIQ_LEN\t64 // sizeof_field(struct hid_device, uniq)\n\n#define _HIDIOCGRAWNAME\t\tHIDIOCGRAWNAME(_HIDIOCGRAWNAME_LEN)\n#define _HIDIOCGRAWPHYS\t\tHIDIOCGRAWPHYS(_HIDIOCGRAWPHYS_LEN)\n#define _HIDIOCGRAWUNIQ\t\tHIDIOCGRAWUNIQ(_HIDIOCGRAWUNIQ_LEN)\n\n'\n\nincludes_NetBSD='\n#include \n#include \n#include \n#include \n#include \n#include ![](\"https://opencollective.com/webhook/contributors.svg?width=890\")
![](\"https://opencollective.com/webhook/backers.svg?width=890\")
\n\n\n### Sponsors\n\nThank you to all our sponsors! (please ask your company to also support this open source project by [becoming a sponsor](https://opencollective.com/webhook#sponsor))\n\n![](\"https://opencollective.com/webhook/sponsor/0/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/1/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/2/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/3/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/4/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/5/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/6/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/7/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/8/avatar.svg\"){kind=avatar}
\n![](\"https://opencollective.com/webhook/sponsor/9/avatar.svg\"){kind=avatar}
\n\n"
},
{
"path": "LICENSE",
"content": "The MIT License (MIT)\n\nCopyright (c) 2015 Adnan Hajdarevic ![\"Webhook\"](\"https://github.com/adnanh/webhook/raw/development/docs/logo/logo-128x128.png\"){kind=logo}
\r\n \r\n [webhook][w] is a lightweight configurable tool written in Go, that allows you to easily create HTTP endpoints (hooks) on your server, which you can use to execute configured commands. You can also pass data from the HTTP request (such as headers, payload or query variables) to your commands. [webhook][w] also allows you to specify rules which have to be satisfied in order for the hook to be triggered.\r\n\r\nFor example, if you're using Github or Bitbucket, you can use [webhook][w] to set up a hook that runs a redeploy script for your project on your staging server, whenever you push changes to the master branch of your project.\r\n\r\nIf you use Mattermost or Slack, you can set up an \"Outgoing webhook integration\" or \"Slash command\" to run various commands on your server, which can then report back directly to you or your channels using the \"Incoming webhook integrations\", or the appropriate response body.\r\n\r\n[webhook][w] aims to do nothing more than it should do, and that is:\r\n 1. receive the request,\r\n 2. parse the headers, payload and query variables,\r\n 3. check if the specified rules for the hook are satisfied,\r\n 3. and finally, pass the specified arguments to the specified command via\r\n command line arguments or via environment variables.\r\n\r\nEverything else is the responsibility of the command's author.\r\n\r\n## Not what you're looking for?\r\n| ![\"hookdoo\"](\"https://hookdoo.com/img/Hookdoo_Logo_1.png\"){kind=logo}
| ![\"hookdeck\"](\"images/hookdeck-white.svg\")
![\"DigitalOcean\"](\"http://www.hajdarevic.net/DO_Logo_Horizontal_Blue.png\"){kind=logo}
\r\n[DigitalOcean](https://www.digitalocean.com/?ref=webhook) is a simple and robust cloud computing platform, designed for developers.\r\n\r\n\r\n## ![\"BrowserStack\"](\"http://www.hajdarevic.net/browserstack.svg\")
\r\n[BrowserStack](https://www.browserstack.com/?ref=webhook) is a cloud-based cross-browser testing tool that enables developers to test their websites across various browsers on different operating systems and mobile devices, without requiring users to install virtual machines, devices or emulators.\r\n\r\n---\r\n\r\nSupport this project by becoming a sponsor. Your logo will show up here with a link to your website.\r\n\r\n