Initial commit

vendor/github.com/360EntSecGroup-Skylar/excelize/BUILD.bazel

@@ -0,0 +1,55 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "cell.go",
+        "chart.go",
+        "col.go",
+        "comment.go",
+        "date.go",
+        "excelize.go",
+        "file.go",
+        "hsl.go",
+        "lib.go",
+        "picture.go",
+        "rows.go",
+        "shape.go",
+        "sheet.go",
+        "sheetpr.go",
+        "sheetview.go",
+        "styles.go",
+        "table.go",
+        "templates.go",
+        "vmlDrawing.go",
+        "xmlChart.go",
+        "xmlComments.go",
+        "xmlContentTypes.go",
+        "xmlDecodeDrawing.go",
+        "xmlDrawing.go",
+        "xmlSharedStrings.go",
+        "xmlStyles.go",
+        "xmlTable.go",
+        "xmlTheme.go",
+        "xmlWorkbook.go",
+        "xmlWorksheet.go",
+    ],
+    importmap = "go-common/vendor/github.com/360EntSecGroup-Skylar/excelize",
+    importpath = "github.com/360EntSecGroup-Skylar/excelize",
+    visibility = ["//visibility:public"],
+    deps = ["//vendor/github.com/mohae/deepcopy:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/360EntSecGroup-Skylar/excelize/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at [xuri.me](https://xuri.me). The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

vendor/github.com/360EntSecGroup-Skylar/excelize/CONTRIBUTING.md

@@ -0,0 +1,375 @@
+# Contributing to excelize
+
+Want to hack on excelize? Awesome! This page contains information about reporting issues as well as some tips and
+guidelines useful to experienced open source contributors. Finally, make sure
+you read our [community guidelines](#community-guidelines) before you
+start participating.
+
+## Topics
+
+* [Reporting Security Issues](#reporting-security-issues)
+* [Design and Cleanup Proposals](#design-and-cleanup-proposals)
+* [Reporting Issues](#reporting-other-issues)
+* [Quick Contribution Tips and Guidelines](#quick-contribution-tips-and-guidelines)
+* [Community Guidelines](#community-guidelines)
+
+## Reporting security issues
+
+The excelize maintainers take security seriously. If you discover a security
+issue, please bring it to their attention right away!
+
+Please **DO NOT** file a public issue, instead send your report privately to
+[xuri.me](https://xuri.me).
+
+Security reports are greatly appreciated and we will publicly thank you for it.
+We currently do not offer a paid security bounty program, but are not
+ruling it out in the future.
+
+## Reporting other issues
+
+A great way to contribute to the project is to send a detailed report when you
+encounter an issue. We always appreciate a well-written, thorough bug report,
+and will thank you for it!
+
+Check that [our issue database](https://github.com/360EntSecGroup-Skylar/excelize/issues)
+doesn't already include that problem or suggestion before submitting an issue.
+If you find a match, you can use the "subscribe" button to get notified on
+updates. Do *not* leave random "+1" or "I have this too" comments, as they
+only clutter the discussion, and don't help resolving it. However, if you
+have ways to reproduce the issue or have additional information that may help
+resolving the issue, please leave a comment.
+
+When reporting issues, always include the output of `go env`.
+
+Also include the steps required to reproduce the problem if possible and
+applicable. This information will help us review and fix your issue faster.
+When sending lengthy log-files, consider posting them as a gist [https://gist.github.com](https://gist.github.com).
+Don't forget to remove sensitive data from your logfiles before posting (you can
+replace those parts with "REDACTED").
+
+## Quick contribution tips and guidelines
+
+This section gives the experienced contributor some tips and guidelines.
+
+### Pull requests are always welcome
+
+Not sure if that typo is worth a pull request? Found a bug and know how to fix
+it? Do it! We will appreciate it. Any significant improvement should be
+documented as [a GitHub issue](https://github.com/360EntSecGroup-Skylar/excelize/issues) before
+anybody starts working on it.
+
+We are always thrilled to receive pull requests. We do our best to process them
+quickly. If your pull request is not accepted on the first try,
+don't get discouraged!
+
+### Design and cleanup proposals
+
+You can propose new designs for existing excelize features. You can also design
+entirely new features. We really appreciate contributors who want to refactor or
+otherwise cleanup our project.
+
+We try hard to keep excelize lean and focused. Excelize can't do everything for
+everybody. This means that we might decide against incorporating a new feature.
+However, there might be a way to implement that feature *on top of* excelize.
+
+### Conventions
+
+Fork the repository and make changes on your fork in a feature branch:
+
+* If it's a bug fix branch, name it XXXX-something where XXXX is the number of
+    the issue.
+* If it's a feature branch, create an enhancement issue to announce
+    your intentions, and name it XXXX-something where XXXX is the number of the
+    issue.
+
+Submit unit tests for your changes. Go has a great test framework built in; use
+it! Take a look at existing tests for inspiration. Run the full test on your branch before
+submitting a pull request.
+
+Update the documentation when creating or modifying features. Test your
+documentation changes for clarity, concision, and correctness, as well as a
+clean documentation build.
+
+Write clean code. Universally formatted code promotes ease of writing, reading,
+and maintenance. Always run `gofmt -s -w file.go` on each changed file before
+committing your changes. Most editors have plug-ins that do this automatically.
+
+Pull request descriptions should be as clear as possible and include a reference
+to all the issues that they address.
+
+### Successful Changes
+
+Before contributing large or high impact changes, make the effort to coordinate
+with the maintainers of the project before submitting a pull request. This
+prevents you from doing extra work that may or may not be merged.
+
+Large PRs that are just submitted without any prior communication are unlikely
+to be successful.
+
+While pull requests are the methodology for submitting changes to code, changes
+are much more likely to be accepted if they are accompanied by additional
+engineering work. While we don't define this explicitly, most of these goals
+are accomplished through communication of the design goals and subsequent
+solutions. Often times, it helps to first state the problem before presenting
+solutions.
+
+Typically, the best methods of accomplishing this are to submit an issue,
+stating the problem. This issue can include a problem statement and a
+checklist with requirements. If solutions are proposed, alternatives should be
+listed and eliminated. Even if the criteria for elimination of a solution is
+frivolous, say so.
+
+Larger changes typically work best with design documents. These are focused on
+providing context to the design at the time the feature was conceived and can
+inform future documentation contributions.
+
+### Commit Messages
+
+Commit messages must start with a capitalized and short summary
+written in the imperative, followed by an optional, more detailed explanatory
+text which is separated from the summary by an empty line.
+
+Commit messages should follow best practices, including explaining the context
+of the problem and how it was solved, including in caveats or follow up changes
+required. They should tell the story of the change and provide readers
+understanding of what led to it.
+
+In practice, the best approach to maintaining a nice commit message is to
+leverage a `git add -p` and `git commit --amend` to formulate a solid
+changeset. This allows one to piece together a change, as information becomes
+available.
+
+If you squash a series of commits, don't just submit that. Re-write the commit
+message, as if the series of commits was a single stroke of brilliance.
+
+That said, there is no requirement to have a single commit for a PR, as long as
+each commit tells the story. For example, if there is a feature that requires a
+package, it might make sense to have the package in a separate commit then have
+a subsequent commit that uses it.
+
+Remember, you're telling part of the story with the commit message. Don't make
+your chapter weird.
+
+### Review
+
+Code review comments may be added to your pull request. Discuss, then make the
+suggested modifications and push additional commits to your feature branch. Post
+a comment after pushing. New commits show up in the pull request automatically,
+but the reviewers are notified only when you comment.
+
+Pull requests must be cleanly rebased on top of master without multiple branches
+mixed into the PR.
+
+**Git tip**: If your PR no longer merges cleanly, use `rebase master` in your
+feature branch to update your pull request rather than `merge master`.
+
+Before you make a pull request, squash your commits into logical units of work
+using `git rebase -i` and `git push -f`. A logical unit of work is a consistent
+set of patches that should be reviewed together: for example, upgrading the
+version of a vendored dependency and taking advantage of its now available new
+feature constitute two separate units of work. Implementing a new function and
+calling it in another file constitute a single logical unit of work. The very
+high majority of submissions should have a single commit, so if in doubt: squash
+down to one.
+
+After every commit, make sure the test passes. Include documentation
+changes in the same pull request so that a revert would remove all traces of
+the feature or fix.
+
+Include an issue reference like `Closes #XXXX` or `Fixes #XXXX` in commits that
+close an issue. Including references automatically closes the issue on a merge.
+
+Please see the [Coding Style](#coding-style) for further guidelines.
+
+### Merge approval
+
+The excelize maintainers use LGTM (Looks Good To Me) in comments on the code review to
+indicate acceptance.
+
+### Sign your work
+
+The sign-off is a simple line at the end of the explanation for the patch. Your
+signature certifies that you wrote the patch or otherwise have the right to pass
+it on as an open-source patch. The rules are pretty simple: if you can certify
+the below (from [developercertificate.org](http://developercertificate.org/)):
+
+```text
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+1 Letterman Drive
+Suite D4700
+San Francisco, CA, 94129
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
+```
+
+Then you just add a line to every git commit message:
+
+    Signed-off-by: Ri Xu https://xuri.me
+
+Use your real name (sorry, no pseudonyms or anonymous contributions.)
+
+If you set your `user.name` and `user.email` git configs, you can sign your
+commit automatically with `git commit -s`.
+
+### How can I become a maintainer
+
+First, all maintainers have 3 things
+
+* They share responsibility in the project's success.
+* They have made a long-term, recurring time investment to improve the project.
+* They spend that time doing whatever needs to be done, not necessarily what
+ is the most interesting or fun.
+
+Maintainers are often under-appreciated, because their work is harder to appreciate.
+It's easy to appreciate a really cool and technically advanced feature. It's harder
+to appreciate the absence of bugs, the slow but steady improvement in stability,
+or the reliability of a release process. But those things distinguish a good
+project from a great one.
+
+Don't forget: being a maintainer is a time investment. Make sure you
+will have time to make yourself available. You don't have to be a
+maintainer to make a difference on the project!
+
+If you want to become a meintainer, contact [xuri.me](https://xuri.me) and given a introduction of you.
+
+## Community guidelines
+
+We want to keep the community awesome, growing and collaborative. We need
+your help to keep it that way. To help with this we've come up with some general
+guidelines for the community as a whole:
+
+* Be nice: Be courteous, respectful and polite to fellow community members:
+  no regional, racial, gender, or other abuse will be tolerated. We like
+  nice people way better than mean ones!
+
+* Encourage diversity and participation: Make everyone in our community feel
+  welcome, regardless of their background and the extent of their
+  contributions, and do everything possible to encourage participation in
+  our community.
+
+* Keep it legal: Basically, don't get us in trouble. Share only content that
+  you own, do not share private or sensitive information, and don't break
+  the law.
+
+* Stay on topic: Make sure that you are posting to the correct channel and
+  avoid off-topic discussions. Remember when you update an issue or respond
+  to an email you are potentially sending to a large number of people. Please
+  consider this before you update. Also remember that nobody likes spam.
+
+* Don't send email to the maintainers: There's no need to send email to the
+  maintainers to ask them to investigate an issue or to take a look at a
+  pull request. Instead of sending an email, GitHub mentions should be
+  used to ping maintainers to review a pull request, a proposal or an
+  issue.
+
+### Guideline violations — 3 strikes method
+
+The point of this section is not to find opportunities to punish people, but we
+do need a fair way to deal with people who are making our community suck.
+
+1. First occurrence: We'll give you a friendly, but public reminder that the
+   behavior is inappropriate according to our guidelines.
+
+2. Second occurrence: We will send you a private message with a warning that
+   any additional violations will result in removal from the community.
+
+3. Third occurrence: Depending on the violation, we may need to delete or ban
+   your account.
+
+**Notes:**
+
+* Obvious spammers are banned on first occurrence. If we don't do this, we'll
+  have spam all over the place.
+
+* Violations are forgiven after 6 months of good behavior, and we won't hold a
+  grudge.
+
+* People who commit minor infractions will get some education, rather than
+  hammering them in the 3 strikes process.
+
+* The rules apply equally to everyone in the community, no matter how much
+    you've contributed.
+
+* Extreme violations of a threatening, abusive, destructive or illegal nature
+    will be addressed immediately and are not subject to 3 strikes or forgiveness.
+
+* Contact [xuri.me](https://xuri.me) to report abuse or appeal violations. In the case of
+    appeals, we know that mistakes happen, and we'll work with you to come up with a
+    fair solution if there has been a misunderstanding.
+
+## Coding Style
+
+Unless explicitly stated, we follow all coding guidelines from the Go
+community. While some of these standards may seem arbitrary, they somehow seem
+to result in a solid, consistent codebase.
+
+It is possible that the code base does not currently comply with these
+guidelines. We are not looking for a massive PR that fixes this, since that
+goes against the spirit of the guidelines. All new contributions should make a
+best effort to clean up and make the code base better than they left it.
+Obviously, apply your best judgement. Remember, the goal here is to make the
+code base easier for humans to navigate and understand. Always keep that in
+mind when nudging others to comply.
+
+The rules:
+
+1. All code should be formatted with `gofmt -s`.
+2. All code should pass the default levels of
+   [`golint`](https://github.com/golang/lint).
+3. All code should follow the guidelines covered in [Effective
+   Go](http://golang.org/doc/effective_go.html) and [Go Code Review
+   Comments](https://github.com/golang/go/wiki/CodeReviewComments).
+4. Comment the code. Tell us the why, the history and the context.
+5. Document _all_ declarations and methods, even private ones. Declare
+   expectations, caveats and anything else that may be important. If a type
+   gets exported, having the comments already there will ensure it's ready.
+6. Variable name length should be proportional to its context and no longer.
+   `noCommaALongVariableNameLikeThisIsNotMoreClearWhenASimpleCommentWouldDo`.
+   In practice, short methods will have short variable names and globals will
+   have longer names.
+7. No underscores in package names. If you need a compound name, step back,
+   and re-examine why you need a compound name. If you still think you need a
+   compound name, lose the underscore.
+8. No utils or helpers packages. If a function is not general enough to
+   warrant its own package, it has not been written generally enough to be a
+   part of a util package. Just leave it unexported and well-documented.
+9. All tests should run with `go test` and outside tooling should not be
+   required. No, we don't need another unit testing framework. Assertion
+   packages are acceptable if they provide _real_ incremental value.
+10. Even though we call these "rules" above, they are actually just
+    guidelines. Since you've read all the rules, you now know that.
+
+If you are having trouble getting into the mood of idiomatic Go, we recommend
+reading through [Effective Go](https://golang.org/doc/effective_go.html). The
+[Go Blog](https://blog.golang.org) is also a great resource. Drinking the
+kool-aid is a lot easier than going thirsty.

vendor/github.com/360EntSecGroup-Skylar/excelize/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2016 - 2018 360 Enterprise Security Group, Endpoint Security,
+inc. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of Excelize nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/360EntSecGroup-Skylar/excelize/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,45 @@
+# PR Details
+
+<!--- Provide a general summary of your changes in the Title above -->
+
+## Description
+
+<!--- Describe your changes in detail -->
+
+## Related Issue
+
+<!--- This project only accepts pull requests related to open issues -->
+<!--- If suggesting a new feature or change, please discuss it in an issue first -->
+<!--- If fixing a bug, there should be an issue describing it with steps to reproduce -->
+<!--- Please link to the issue here: -->
+
+## Motivation and Context
+
+<!--- Why is this change required? What problem does it solve? -->
+
+## How Has This Been Tested
+
+<!--- Please describe in detail how you tested your changes. -->
+<!--- Include details of your testing environment, and the tests you ran to -->
+<!--- see how your change affects other areas of the code, etc. -->
+
+## Types of changes
+
+<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
+
+- [ ] Docs change / refactoring / dependency upgrade
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to change)
+
+## Checklist
+
+<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
+<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
+
+- [ ] My code follows the code style of this project.
+- [ ] My change requires a change to the documentation.
+- [ ] I have updated the documentation accordingly.
+- [ ] I have read the **CONTRIBUTING** document.
+- [ ] I have added tests to cover my changes.
+- [ ] All new and existing tests passed.

vendor/github.com/360EntSecGroup-Skylar/excelize/README.md

@@ -0,0 +1,175 @@
+![Excelize](./excelize.png "Excelize")
+
+# Excelize
+
+[![Build Status](https://travis-ci.org/360EntSecGroup-Skylar/excelize.svg?branch=master)](https://travis-ci.org/360EntSecGroup-Skylar/excelize)
+[![Code Coverage](https://codecov.io/gh/360EntSecGroup-Skylar/excelize/branch/master/graph/badge.svg)](https://codecov.io/gh/360EntSecGroup-Skylar/excelize)
+[![Go Report Card](https://goreportcard.com/badge/github.com/360EntSecGroup-Skylar/excelize)](https://goreportcard.com/report/github.com/360EntSecGroup-Skylar/excelize)
+[![GoDoc](https://godoc.org/github.com/360EntSecGroup-Skylar/excelize?status.svg)](https://godoc.org/github.com/360EntSecGroup-Skylar/excelize)
+[![Licenses](https://img.shields.io/badge/license-bsd-orange.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/xuri)
+
+## Introduction
+
+Excelize is a library written in pure Go and providing a set of functions that allow you to write to and read from XLSX files. Support reads and writes XLSX file generated by Microsoft Excel™ 2007 and later. Support save file without losing original charts of XLSX. This library needs Go version 1.8 or later. The full API docs can be seen using go's built-in documentation tool, or online at [godoc.org](https://godoc.org/github.com/360EntSecGroup-Skylar/excelize) and [docs reference](https://xuri.me/excelize/).
+
+## Basic Usage
+
+### Installation
+
+```go
+go get github.com/360EntSecGroup-Skylar/excelize
+```
+
+### Create XLSX file
+
+Here is a minimal example usage that will create XLSX file.
+
+```go
+package main
+
+import (
+    "fmt"
+
+    "github.com/360EntSecGroup-Skylar/excelize"
+)
+
+func main() {
+    xlsx := excelize.NewFile()
+    // Create a new sheet.
+    index := xlsx.NewSheet("Sheet2")
+    // Set value of a cell.
+    xlsx.SetCellValue("Sheet2", "A2", "Hello world.")
+    xlsx.SetCellValue("Sheet1", "B2", 100)
+    // Set active sheet of the workbook.
+    xlsx.SetActiveSheet(index)
+    // Save xlsx file by the given path.
+    err := xlsx.SaveAs("./Book1.xlsx")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
+### Reading XLSX file
+
+The following constitutes the bare to read a XLSX document.
+
+```go
+package main
+
+import (
+    "fmt"
+
+    "github.com/360EntSecGroup-Skylar/excelize"
+)
+
+func main() {
+    xlsx, err := excelize.OpenFile("./Book1.xlsx")
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // Get value from cell by given worksheet name and axis.
+    cell := xlsx.GetCellValue("Sheet1", "B2")
+    fmt.Println(cell)
+    // Get all the rows in the Sheet1.
+    rows := xlsx.GetRows("Sheet1")
+    for _, row := range rows {
+        for _, colCell := range row {
+            fmt.Print(colCell, "\t")
+        }
+        fmt.Println()
+    }
+}
+```
+
+### Add chart to XLSX file
+
+With Excelize chart generation and management is as easy as a few lines of code. You can build charts based off data in your worksheet or generate charts without any data in your worksheet at all.
+
+![Excelize](./test/images/chart.png "Excelize")
+
+```go
+package main
+
+import (
+    "fmt"
+
+    "github.com/360EntSecGroup-Skylar/excelize"
+)
+
+func main() {
+    categories := map[string]string{"A2": "Small", "A3": "Normal", "A4": "Large", "B1": "Apple", "C1": "Orange", "D1": "Pear"}
+    values := map[string]int{"B2": 2, "C2": 3, "D2": 3, "B3": 5, "C3": 2, "D3": 4, "B4": 6, "C4": 7, "D4": 8}
+    xlsx := excelize.NewFile()
+    for k, v := range categories {
+        xlsx.SetCellValue("Sheet1", k, v)
+    }
+    for k, v := range values {
+        xlsx.SetCellValue("Sheet1", k, v)
+    }
+    xlsx.AddChart("Sheet1", "E1", `{"type":"col3DClustered","series":[{"name":"Sheet1!$A$2","categories":"Sheet1!$B$1:$D$1","values":"Sheet1!$B$2:$D$2"},{"name":"Sheet1!$A$3","categories":"Sheet1!$B$1:$D$1","values":"Sheet1!$B$3:$D$3"},{"name":"Sheet1!$A$4","categories":"Sheet1!$B$1:$D$1","values":"Sheet1!$B$4:$D$4"}],"title":{"name":"Fruit 3D Clustered Column Chart"}}`)
+    // Save xlsx file by the given path.
+    err := xlsx.SaveAs("./Book1.xlsx")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+
+```
+
+### Add picture to XLSX file
+
+```go
+package main
+
+import (
+    "fmt"
+    _ "image/gif"
+    _ "image/jpeg"
+    _ "image/png"
+
+    "github.com/360EntSecGroup-Skylar/excelize"
+)
+
+func main() {
+    xlsx, err := excelize.OpenFile("./Book1.xlsx")
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // Insert a picture.
+    err = xlsx.AddPicture("Sheet1", "A2", "./image1.png", "")
+    if err != nil {
+        fmt.Println(err)
+    }
+    // Insert a picture to worksheet with scaling.
+    err = xlsx.AddPicture("Sheet1", "D2", "./image2.jpg", `{"x_scale": 0.5, "y_scale": 0.5}`)
+    if err != nil {
+        fmt.Println(err)
+    }
+    // Insert a picture offset in the cell with printing support.
+    err = xlsx.AddPicture("Sheet1", "H2", "./image3.gif", `{"x_offset": 15, "y_offset": 10, "print_obj": true, "lock_aspect_ratio": false, "locked": false}`)
+    if err != nil {
+        fmt.Println(err)
+    }
+    // Save the xlsx file with the origin path.
+    err = xlsx.Save()
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
+## Contributing
+
+Contributions are welcome! Open a pull request to fix a bug, or open an issue to discuss a new feature or change. XML is compliant with [part 1 of the 5th edition of the ECMA-376 Standard for Office Open XML](http://www.ecma-international.org/publications/standards/Ecma-376.htm).
+
+## Credits
+
+Some struct of XML originally by [tealeg/xlsx](https://github.com/tealeg/xlsx).
+
+## Licenses
+
+This program is under the terms of the BSD 3-Clause License. See [https://opensource.org/licenses/BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause).

vendor/github.com/360EntSecGroup-Skylar/excelize/README_zh.md

@@ -0,0 +1,175 @@
+![Excelize](./excelize.png "Excelize")
+
+# Excelize
+
+[![Build Status](https://travis-ci.org/360EntSecGroup-Skylar/excelize.svg?branch=master)](https://travis-ci.org/360EntSecGroup-Skylar/excelize)
+[![Code Coverage](https://codecov.io/gh/360EntSecGroup-Skylar/excelize/branch/master/graph/badge.svg)](https://codecov.io/gh/360EntSecGroup-Skylar/excelize)
+[![Go Report Card](https://goreportcard.com/badge/github.com/360EntSecGroup-Skylar/excelize)](https://goreportcard.com/report/github.com/360EntSecGroup-Skylar/excelize)
+[![GoDoc](https://godoc.org/github.com/360EntSecGroup-Skylar/excelize?status.svg)](https://godoc.org/github.com/360EntSecGroup-Skylar/excelize)
+[![Licenses](https://img.shields.io/badge/license-bsd-orange.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/xuri)
+
+## 简介
+
+Excelize 是 Go 语言编写的用于操作 Office Excel 文档类库，基于 ECMA-376 Office OpenXML 标准。可以使用它来读取、写入由 Microsoft Excel™ 2007 及以上版本创建的 XLSX 文档。相比较其他的开源类库，Excelize 支持写入原本带有图片(表)、透视表和切片器等复杂样式的文档，还支持向 Excel 文档中插入图片与图表，并且在保存后不会丢失文档原有样式，可以应用于各类报表系统中。使用本类库要求使用的 Go 语言为 1.8 或更高版本，完整的 API 使用文档请访问 [godoc.org](https://godoc.org/github.com/360EntSecGroup-Skylar/excelize) 或查看 [参考文档](https://xuri.me/excelize/)。
+
+## 快速上手
+
+### 安装
+
+```go
+go get github.com/360EntSecGroup-Skylar/excelize
+```
+
+### 创建 Excel 文档
+
+下面是一个创建 Excel 文档的简单例子：
+
+```go
+package main
+
+import (
+    "fmt"
+
+    "github.com/360EntSecGroup-Skylar/excelize"
+)
+
+func main() {
+    xlsx := excelize.NewFile()
+    // 创建一个工作表
+    index := xlsx.NewSheet("Sheet2")
+    // 设置单元格的值
+    xlsx.SetCellValue("Sheet2", "A2", "Hello world.")
+    xlsx.SetCellValue("Sheet1", "B2", 100)
+    // 设置工作簿的默认工作表
+    xlsx.SetActiveSheet(index)
+    // 根据指定路径保存文件
+    err := xlsx.SaveAs("./Book1.xlsx")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
+### 读取 Excel 文档
+
+下面是读取 Excel 文档的例子：
+
+```go
+package main
+
+import (
+    "fmt"
+
+    "github.com/360EntSecGroup-Skylar/excelize"
+)
+
+func main() {
+    xlsx, err := excelize.OpenFile("./Book1.xlsx")
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // 获取工作表中指定单元格的值
+    cell := xlsx.GetCellValue("Sheet1", "B2")
+    fmt.Println(cell)
+    // 获取 Sheet1 上所有单元格
+    rows := xlsx.GetRows("Sheet1")
+    for _, row := range rows {
+        for _, colCell := range row {
+            fmt.Print(colCell, "\t")
+        }
+        fmt.Println()
+    }
+}
+```
+
+### 在 Excel 文档中创建图表
+
+使用 Excelize 生成图表十分简单，仅需几行代码。您可以根据工作表中的已有数据构建图表，或向工作表中添加数据并创建图表。
+
+![Excelize](./test/images/chart.png "Excelize")
+
+```go
+package main
+
+import (
+    "fmt"
+
+    "github.com/360EntSecGroup-Skylar/excelize"
+)
+
+func main() {
+    categories := map[string]string{"A2": "Small", "A3": "Normal", "A4": "Large", "B1": "Apple", "C1": "Orange", "D1": "Pear"}
+    values := map[string]int{"B2": 2, "C2": 3, "D2": 3, "B3": 5, "C3": 2, "D3": 4, "B4": 6, "C4": 7, "D4": 8}
+    xlsx := excelize.NewFile()
+    for k, v := range categories {
+        xlsx.SetCellValue("Sheet1", k, v)
+    }
+    for k, v := range values {
+        xlsx.SetCellValue("Sheet1", k, v)
+    }
+    xlsx.AddChart("Sheet1", "E1", `{"type":"col3DClustered","series":[{"name":"Sheet1!$A$2","categories":"Sheet1!$B$1:$D$1","values":"Sheet1!$B$2:$D$2"},{"name":"Sheet1!$A$3","categories":"Sheet1!$B$1:$D$1","values":"Sheet1!$B$3:$D$3"},{"name":"Sheet1!$A$4","categories":"Sheet1!$B$1:$D$1","values":"Sheet1!$B$4:$D$4"}],"title":{"name":"Fruit 3D Clustered Column Chart"}}`)
+    // 根据指定路径保存文件
+    err := xlsx.SaveAs("./Book1.xlsx")
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+
+```
+
+### 向 Excel 文档中插入图片
+
+```go
+package main
+
+import (
+    "fmt"
+    _ "image/gif"
+    _ "image/jpeg"
+    _ "image/png"
+
+    "github.com/360EntSecGroup-Skylar/excelize"
+)
+
+func main() {
+    xlsx, err := excelize.OpenFile("./Book1.xlsx")
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    // 插入图片
+    err = xlsx.AddPicture("Sheet1", "A2", "./image1.png", "")
+    if err != nil {
+        fmt.Println(err)
+    }
+    // 在工作表中插入图片，并设置图片的缩放比例
+    err = xlsx.AddPicture("Sheet1", "D2", "./image2.jpg", `{"x_scale": 0.5, "y_scale": 0.5}`)
+    if err != nil {
+        fmt.Println(err)
+    }
+    // 在工作表中插入图片，并设置图片的打印属性
+    err = xlsx.AddPicture("Sheet1", "H2", "./image3.gif", `{"x_offset": 15, "y_offset": 10, "print_obj": true, "lock_aspect_ratio": false, "locked": false}`)
+    if err != nil {
+        fmt.Println(err)
+    }
+    // 保存文件
+    err = xlsx.Save()
+    if err != nil {
+        fmt.Println(err)
+    }
+}
+```
+
+## 社区合作
+
+欢迎您为此项目贡献代码，提出建议或问题、修复 Bug 以及参与讨论对新功能的想法。 XML 符合标准： [part 1 of the 5th edition of the ECMA-376 Standard for Office Open XML](http://www.ecma-international.org/publications/standards/Ecma-376.htm)。
+
+## 致谢
+
+本类库中部分 XML 结构体的定义参考了开源项目：[tealeg/xlsx](https://github.com/tealeg/xlsx).
+
+## 开源许可
+
+本项目遵循 BSD 3-Clause 开源许可协议，访问 [https://opensource.org/licenses/BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause) 查看许可协议文件。

vendor/github.com/360EntSecGroup-Skylar/excelize/cell.go

@@ -0,0 +1,589 @@
+package excelize
+
+import (
+	"encoding/xml"
+	"fmt"
+	"reflect"
+	"strconv"
+	"strings"
+	"time"
+)
+
+const (
+	// STCellFormulaTypeArray defined the formula is an array formula.
+	STCellFormulaTypeArray = "array"
+	// STCellFormulaTypeDataTable defined the formula is a data table formula.
+	STCellFormulaTypeDataTable = "dataTable"
+	// STCellFormulaTypeNormal defined the formula is a regular cell formula.
+	STCellFormulaTypeNormal = "normal"
+	// STCellFormulaTypeShared defined the formula is part of a shared formula.
+	STCellFormulaTypeShared = "shared"
+)
+
+// mergeCellsParser provides a function to check merged cells in worksheet by
+// given axis.
+func (f *File) mergeCellsParser(xlsx *xlsxWorksheet, axis string) string {
+	axis = strings.ToUpper(axis)
+	if xlsx.MergeCells != nil {
+		for i := 0; i < len(xlsx.MergeCells.Cells); i++ {
+			if checkCellInArea(axis, xlsx.MergeCells.Cells[i].Ref) {
+				axis = strings.Split(xlsx.MergeCells.Cells[i].Ref, ":")[0]
+			}
+		}
+	}
+	return axis
+}
+
+// SetCellValue provides a function to set value of a cell. The following
+// shows the supported data types:
+//
+//    int
+//    int8
+//    int16
+//    int32
+//    int64
+//    uint
+//    uint8
+//    uint16
+//    uint32
+//    uint64
+//    float32
+//    float64
+//    string
+//    []byte
+//    time.Duration
+//    time.Time
+//    bool
+//    nil
+//
+// Note that default date format is m/d/yy h:mm of time.Time type value. You can
+// set numbers format by SetCellStyle() method.
+func (f *File) SetCellValue(sheet, axis string, value interface{}) {
+	switch t := value.(type) {
+	case float32:
+		f.SetCellDefault(sheet, axis, strconv.FormatFloat(float64(value.(float32)), 'f', -1, 32))
+	case float64:
+		f.SetCellDefault(sheet, axis, strconv.FormatFloat(float64(value.(float64)), 'f', -1, 64))
+	case string:
+		f.SetCellStr(sheet, axis, t)
+	case []byte:
+		f.SetCellStr(sheet, axis, string(t))
+	case time.Duration:
+		f.SetCellDefault(sheet, axis, strconv.FormatFloat(float64(value.(time.Duration).Seconds()/86400), 'f', -1, 32))
+		f.setDefaultTimeStyle(sheet, axis, 21)
+	case time.Time:
+		f.SetCellDefault(sheet, axis, strconv.FormatFloat(float64(timeToExcelTime(timeToUTCTime(value.(time.Time)))), 'f', -1, 64))
+		f.setDefaultTimeStyle(sheet, axis, 22)
+	case nil:
+		f.SetCellStr(sheet, axis, "")
+	case bool:
+		f.SetCellBool(sheet, axis, bool(value.(bool)))
+	default:
+		f.setCellIntValue(sheet, axis, value)
+	}
+}
+
+// setCellIntValue provides a function to set int value of a cell.
+func (f *File) setCellIntValue(sheet, axis string, value interface{}) {
+	switch value.(type) {
+	case int:
+		f.SetCellInt(sheet, axis, value.(int))
+	case int8:
+		f.SetCellInt(sheet, axis, int(value.(int8)))
+	case int16:
+		f.SetCellInt(sheet, axis, int(value.(int16)))
+	case int32:
+		f.SetCellInt(sheet, axis, int(value.(int32)))
+	case int64:
+		f.SetCellInt(sheet, axis, int(value.(int64)))
+	case uint:
+		f.SetCellInt(sheet, axis, int(value.(uint)))
+	case uint8:
+		f.SetCellInt(sheet, axis, int(value.(uint8)))
+	case uint16:
+		f.SetCellInt(sheet, axis, int(value.(uint16)))
+	case uint32:
+		f.SetCellInt(sheet, axis, int(value.(uint32)))
+	case uint64:
+		f.SetCellInt(sheet, axis, int(value.(uint64)))
+	default:
+		f.SetCellStr(sheet, axis, fmt.Sprintf("%v", value))
+	}
+}
+
+// SetCellBool provides a function to set bool type value of a cell by given
+// worksheet name, cell coordinates and cell value.
+func (f *File) SetCellBool(sheet, axis string, value bool) {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	col := string(strings.Map(letterOnlyMapF, axis))
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return
+	}
+	xAxis := row - 1
+	yAxis := TitleToNumber(col)
+
+	rows := xAxis + 1
+	cell := yAxis + 1
+
+	completeRow(xlsx, rows, cell)
+	completeCol(xlsx, rows, cell)
+
+	xlsx.SheetData.Row[xAxis].C[yAxis].S = f.prepareCellStyle(xlsx, cell, xlsx.SheetData.Row[xAxis].C[yAxis].S)
+	xlsx.SheetData.Row[xAxis].C[yAxis].T = "b"
+	if value {
+		xlsx.SheetData.Row[xAxis].C[yAxis].V = "1"
+	} else {
+		xlsx.SheetData.Row[xAxis].C[yAxis].V = "0"
+	}
+}
+
+// GetCellValue provides a function to get formatted value from cell by given
+// worksheet name and axis in XLSX file. If it is possible to apply a format
+// to the cell value, it will do so, if not then an error will be returned,
+// along with the raw value of the cell.
+func (f *File) GetCellValue(sheet, axis string) string {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return ""
+	}
+	xAxis := row - 1
+	rows := len(xlsx.SheetData.Row)
+	if rows > 1 {
+		lastRow := xlsx.SheetData.Row[rows-1].R
+		if lastRow >= rows {
+			rows = lastRow
+		}
+	}
+	if rows < xAxis {
+		return ""
+	}
+	for k := range xlsx.SheetData.Row {
+		if xlsx.SheetData.Row[k].R == row {
+			for i := range xlsx.SheetData.Row[k].C {
+				if axis == xlsx.SheetData.Row[k].C[i].R {
+					val, _ := xlsx.SheetData.Row[k].C[i].getValueFrom(f, f.sharedStringsReader())
+					return val
+				}
+			}
+		}
+	}
+	return ""
+}
+
+// formattedValue provides a function to returns a value after formatted. If
+// it is possible to apply a format to the cell value, it will do so, if not
+// then an error will be returned, along with the raw value of the cell.
+func (f *File) formattedValue(s int, v string) string {
+	if s == 0 {
+		return v
+	}
+	styleSheet := f.stylesReader()
+	ok := builtInNumFmtFunc[styleSheet.CellXfs.Xf[s].NumFmtID]
+	if ok != nil {
+		return ok(styleSheet.CellXfs.Xf[s].NumFmtID, v)
+	}
+	return v
+}
+
+// GetCellStyle provides a function to get cell style index by given worksheet
+// name and cell coordinates.
+func (f *File) GetCellStyle(sheet, axis string) int {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	col := string(strings.Map(letterOnlyMapF, axis))
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return 0
+	}
+	xAxis := row - 1
+	yAxis := TitleToNumber(col)
+
+	rows := xAxis + 1
+	cell := yAxis + 1
+
+	completeRow(xlsx, rows, cell)
+	completeCol(xlsx, rows, cell)
+
+	return f.prepareCellStyle(xlsx, cell, xlsx.SheetData.Row[xAxis].C[yAxis].S)
+}
+
+// GetCellFormula provides a function to get formula from cell by given
+// worksheet name and axis in XLSX file.
+func (f *File) GetCellFormula(sheet, axis string) string {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return ""
+	}
+	xAxis := row - 1
+	rows := len(xlsx.SheetData.Row)
+	if rows > 1 {
+		lastRow := xlsx.SheetData.Row[rows-1].R
+		if lastRow >= rows {
+			rows = lastRow
+		}
+	}
+	if rows < xAxis {
+		return ""
+	}
+	for k := range xlsx.SheetData.Row {
+		if xlsx.SheetData.Row[k].R == row {
+			for i := range xlsx.SheetData.Row[k].C {
+				if axis == xlsx.SheetData.Row[k].C[i].R {
+					if xlsx.SheetData.Row[k].C[i].F.T == STCellFormulaTypeShared {
+						return getSharedForumula(xlsx, xlsx.SheetData.Row[k].C[i].F.Si)
+					}
+					if xlsx.SheetData.Row[k].C[i].F != nil {
+						return xlsx.SheetData.Row[k].C[i].F.Content
+					}
+				}
+			}
+		}
+	}
+	return ""
+}
+
+// getSharedForumula find a cell contains the same formula as another cell,
+// the "shared" value can be used for the t attribute and the si attribute can
+// be used to refer to the cell containing the formula. Two formulas are
+// considered to be the same when their respective representations in
+// R1C1-reference notation, are the same.
+//
+// Note that this function not validate ref tag to check the cell if or not in
+// allow area, and always return origin shared formula.
+func getSharedForumula(xlsx *xlsxWorksheet, si string) string {
+	for k := range xlsx.SheetData.Row {
+		for i := range xlsx.SheetData.Row[k].C {
+			if xlsx.SheetData.Row[k].C[i].F == nil {
+				continue
+			}
+			if xlsx.SheetData.Row[k].C[i].F.T != STCellFormulaTypeShared {
+				continue
+			}
+			if xlsx.SheetData.Row[k].C[i].F.Si != si {
+				continue
+			}
+			if xlsx.SheetData.Row[k].C[i].F.Ref != "" {
+				return xlsx.SheetData.Row[k].C[i].F.Content
+			}
+		}
+	}
+	return ""
+}
+
+// SetCellFormula provides a function to set cell formula by given string and
+// worksheet name.
+func (f *File) SetCellFormula(sheet, axis, formula string) {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	col := string(strings.Map(letterOnlyMapF, axis))
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return
+	}
+	xAxis := row - 1
+	yAxis := TitleToNumber(col)
+
+	rows := xAxis + 1
+	cell := yAxis + 1
+
+	completeRow(xlsx, rows, cell)
+	completeCol(xlsx, rows, cell)
+
+	if xlsx.SheetData.Row[xAxis].C[yAxis].F != nil {
+		xlsx.SheetData.Row[xAxis].C[yAxis].F.Content = formula
+	} else {
+		f := xlsxF{
+			Content: formula,
+		}
+		xlsx.SheetData.Row[xAxis].C[yAxis].F = &f
+	}
+}
+
+// SetCellHyperLink provides a function to set cell hyperlink by given
+// worksheet name and link URL address. LinkType defines two types of
+// hyperlink "External" for web site or "Location" for moving to one of cell
+// in this workbook. The below is example for external link.
+//
+//    xlsx.SetCellHyperLink("Sheet1", "A3", "https://github.com/360EntSecGroup-Skylar/excelize", "External")
+//    // Set underline and font color style for the cell.
+//    style, _ := xlsx.NewStyle(`{"font":{"color":"#1265BE","underline":"single"}}`)
+//    xlsx.SetCellStyle("Sheet1", "A3", "A3", style)
+//
+// A this is another example for "Location":
+//
+//    xlsx.SetCellHyperLink("Sheet1", "A3", "Sheet1!A40", "Location")
+//
+func (f *File) SetCellHyperLink(sheet, axis, link, linkType string) {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	linkTypes := map[string]xlsxHyperlink{
+		"External": {},
+		"Location": {Location: link},
+	}
+	hyperlink, ok := linkTypes[linkType]
+	if !ok || axis == "" {
+		return
+	}
+	hyperlink.Ref = axis
+	if linkType == "External" {
+		rID := f.addSheetRelationships(sheet, SourceRelationshipHyperLink, link, linkType)
+		hyperlink.RID = "rId" + strconv.Itoa(rID)
+	}
+	if xlsx.Hyperlinks == nil {
+		xlsx.Hyperlinks = &xlsxHyperlinks{}
+	}
+	xlsx.Hyperlinks.Hyperlink = append(xlsx.Hyperlinks.Hyperlink, hyperlink)
+}
+
+// GetCellHyperLink provides a function to get cell hyperlink by given
+// worksheet name and axis. Boolean type value link will be ture if the cell
+// has a hyperlink and the target is the address of the hyperlink. Otherwise,
+// the value of link will be false and the value of the target will be a blank
+// string. For example get hyperlink of Sheet1!H6:
+//
+//    link, target := xlsx.GetCellHyperLink("Sheet1", "H6")
+//
+func (f *File) GetCellHyperLink(sheet, axis string) (bool, string) {
+	var link bool
+	var target string
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	if xlsx.Hyperlinks == nil || axis == "" {
+		return link, target
+	}
+	for h := range xlsx.Hyperlinks.Hyperlink {
+		if xlsx.Hyperlinks.Hyperlink[h].Ref == axis {
+			link = true
+			target = xlsx.Hyperlinks.Hyperlink[h].Location
+			if xlsx.Hyperlinks.Hyperlink[h].RID != "" {
+				target = f.getSheetRelationshipsTargetByID(sheet, xlsx.Hyperlinks.Hyperlink[h].RID)
+			}
+		}
+	}
+	return link, target
+}
+
+// MergeCell provides a function to merge cells by given coordinate area and
+// sheet name. For example create a merged cell of D3:E9 on Sheet1:
+//
+//    xlsx.MergeCell("Sheet1", "D3", "E9")
+//
+// If you create a merged cell that overlaps with another existing merged cell,
+// those merged cells that already exist will be removed.
+func (f *File) MergeCell(sheet, hcell, vcell string) {
+	if hcell == vcell {
+		return
+	}
+
+	hcell = strings.ToUpper(hcell)
+	vcell = strings.ToUpper(vcell)
+
+	// Coordinate conversion, convert C1:B3 to 2,0,1,2.
+	hcol := string(strings.Map(letterOnlyMapF, hcell))
+	hrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, hcell))
+	hyAxis := hrow - 1
+	hxAxis := TitleToNumber(hcol)
+
+	vcol := string(strings.Map(letterOnlyMapF, vcell))
+	vrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, vcell))
+	vyAxis := vrow - 1
+	vxAxis := TitleToNumber(vcol)
+
+	if vxAxis < hxAxis {
+		hcell, vcell = vcell, hcell
+		vxAxis, hxAxis = hxAxis, vxAxis
+	}
+
+	if vyAxis < hyAxis {
+		hcell, vcell = vcell, hcell
+		vyAxis, hyAxis = hyAxis, vyAxis
+	}
+
+	xlsx := f.workSheetReader(sheet)
+	if xlsx.MergeCells != nil {
+		mergeCell := xlsxMergeCell{}
+		// Correct the coordinate area, such correct C1:B3 to B1:C3.
+		mergeCell.Ref = ToAlphaString(hxAxis) + strconv.Itoa(hyAxis+1) + ":" + ToAlphaString(vxAxis) + strconv.Itoa(vyAxis+1)
+		// Delete the merged cells of the overlapping area.
+		for i := 0; i < len(xlsx.MergeCells.Cells); i++ {
+			if checkCellInArea(hcell, xlsx.MergeCells.Cells[i].Ref) || checkCellInArea(strings.Split(xlsx.MergeCells.Cells[i].Ref, ":")[0], mergeCell.Ref) {
+				xlsx.MergeCells.Cells = append(xlsx.MergeCells.Cells[:i], xlsx.MergeCells.Cells[i+1:]...)
+			} else if checkCellInArea(vcell, xlsx.MergeCells.Cells[i].Ref) || checkCellInArea(strings.Split(xlsx.MergeCells.Cells[i].Ref, ":")[1], mergeCell.Ref) {
+				xlsx.MergeCells.Cells = append(xlsx.MergeCells.Cells[:i], xlsx.MergeCells.Cells[i+1:]...)
+			}
+		}
+		xlsx.MergeCells.Cells = append(xlsx.MergeCells.Cells, &mergeCell)
+	} else {
+		mergeCell := xlsxMergeCell{}
+		// Correct the coordinate area, such correct C1:B3 to B1:C3.
+		mergeCell.Ref = ToAlphaString(hxAxis) + strconv.Itoa(hyAxis+1) + ":" + ToAlphaString(vxAxis) + strconv.Itoa(vyAxis+1)
+		mergeCells := xlsxMergeCells{}
+		mergeCells.Cells = append(mergeCells.Cells, &mergeCell)
+		xlsx.MergeCells = &mergeCells
+	}
+}
+
+// SetCellInt provides a function to set int type value of a cell by given
+// worksheet name, cell coordinates and cell value.
+func (f *File) SetCellInt(sheet, axis string, value int) {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	col := string(strings.Map(letterOnlyMapF, axis))
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return
+	}
+	xAxis := row - 1
+	yAxis := TitleToNumber(col)
+
+	rows := xAxis + 1
+	cell := yAxis + 1
+
+	completeRow(xlsx, rows, cell)
+	completeCol(xlsx, rows, cell)
+
+	xlsx.SheetData.Row[xAxis].C[yAxis].S = f.prepareCellStyle(xlsx, cell, xlsx.SheetData.Row[xAxis].C[yAxis].S)
+	xlsx.SheetData.Row[xAxis].C[yAxis].T = ""
+	xlsx.SheetData.Row[xAxis].C[yAxis].V = strconv.Itoa(value)
+}
+
+// prepareCellStyle provides a function to prepare style index of cell in
+// worksheet by given column index and style index.
+func (f *File) prepareCellStyle(xlsx *xlsxWorksheet, col, style int) int {
+	if xlsx.Cols != nil && style == 0 {
+		for _, v := range xlsx.Cols.Col {
+			if v.Min <= col && col <= v.Max {
+				style = v.Style
+			}
+		}
+	}
+	return style
+}
+
+// SetCellStr provides a function to set string type value of a cell. Total
+// number of characters that a cell can contain 32767 characters.
+func (f *File) SetCellStr(sheet, axis, value string) {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	if len(value) > 32767 {
+		value = value[0:32767]
+	}
+	col := string(strings.Map(letterOnlyMapF, axis))
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return
+	}
+	xAxis := row - 1
+	yAxis := TitleToNumber(col)
+
+	rows := xAxis + 1
+	cell := yAxis + 1
+
+	completeRow(xlsx, rows, cell)
+	completeCol(xlsx, rows, cell)
+
+	// Leading space(s) character detection.
+	if len(value) > 0 {
+		if value[0] == 32 {
+			xlsx.SheetData.Row[xAxis].C[yAxis].XMLSpace = xml.Attr{
+				Name:  xml.Name{Space: NameSpaceXML, Local: "space"},
+				Value: "preserve",
+			}
+		}
+	}
+	xlsx.SheetData.Row[xAxis].C[yAxis].S = f.prepareCellStyle(xlsx, cell, xlsx.SheetData.Row[xAxis].C[yAxis].S)
+	xlsx.SheetData.Row[xAxis].C[yAxis].T = "str"
+	xlsx.SheetData.Row[xAxis].C[yAxis].V = value
+}
+
+// SetCellDefault provides a function to set string type value of a cell as
+// default format without escaping the cell.
+func (f *File) SetCellDefault(sheet, axis, value string) {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	col := string(strings.Map(letterOnlyMapF, axis))
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return
+	}
+	xAxis := row - 1
+	yAxis := TitleToNumber(col)
+
+	rows := xAxis + 1
+	cell := yAxis + 1
+
+	completeRow(xlsx, rows, cell)
+	completeCol(xlsx, rows, cell)
+
+	xlsx.SheetData.Row[xAxis].C[yAxis].S = f.prepareCellStyle(xlsx, cell, xlsx.SheetData.Row[xAxis].C[yAxis].S)
+	xlsx.SheetData.Row[xAxis].C[yAxis].T = ""
+	xlsx.SheetData.Row[xAxis].C[yAxis].V = value
+}
+
+// SetSheetRow writes an array to row by given worksheet name, starting
+// coordinate and a pointer to array type 'slice'. For example, writes an
+// array to row 6 start with the cell B6 on Sheet1:
+//
+//     xlsx.SetSheetRow("Sheet1", "B6", &[]interface{}{"1", nil, 2})
+//
+func (f *File) SetSheetRow(sheet, axis string, slice interface{}) {
+	xlsx := f.workSheetReader(sheet)
+	axis = f.mergeCellsParser(xlsx, axis)
+	col := string(strings.Map(letterOnlyMapF, axis))
+	row, err := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+	if err != nil {
+		return
+	}
+	// Make sure 'slice' is a Ptr to Slice
+	v := reflect.ValueOf(slice)
+	if v.Kind() != reflect.Ptr {
+		return
+	}
+	v = v.Elem()
+	if v.Kind() != reflect.Slice {
+		return
+	}
+
+	xAxis := row - 1
+	yAxis := TitleToNumber(col)
+
+	rows := xAxis + 1
+	cell := yAxis + 1
+
+	completeRow(xlsx, rows, cell)
+	completeCol(xlsx, rows, cell)
+
+	idx := 0
+	for i := cell - 1; i < v.Len()+cell-1; i++ {
+		c := ToAlphaString(i) + strconv.Itoa(row)
+		f.SetCellValue(sheet, c, v.Index(idx).Interface())
+		idx++
+	}
+}
+
+// checkCellInArea provides a function to determine if a given coordinate is
+// within an area.
+func checkCellInArea(cell, area string) bool {
+	cell = strings.ToUpper(cell)
+	area = strings.ToUpper(area)
+
+	ref := strings.Split(area, ":")
+	if len(ref) < 2 {
+		return false
+	}
+
+	from := ref[0]
+	to := ref[1]
+
+	col, row := getCellColRow(cell)
+	fromCol, fromRow := getCellColRow(from)
+	toCol, toRow := getCellColRow(to)
+
+	return axisLowerOrEqualThan(fromCol, col) && axisLowerOrEqualThan(col, toCol) && axisLowerOrEqualThan(fromRow, row) && axisLowerOrEqualThan(row, toRow)
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/col.go

@@ -0,0 +1,366 @@
+package excelize
+
+import (
+	"bytes"
+	"math"
+	"strconv"
+	"strings"
+)
+
+// Define the default cell size and EMU unit of measurement.
+const (
+	defaultColWidthPixels  float64 = 64
+	defaultRowHeightPixels float64 = 20
+	EMU                    int     = 9525
+)
+
+// GetColVisible provides a function to get visible of a single column by given
+// worksheet name and column name. For example, get visible state of column D
+// in Sheet1:
+//
+//    xlsx.GetColVisible("Sheet1", "D")
+//
+func (f *File) GetColVisible(sheet, column string) bool {
+	xlsx := f.workSheetReader(sheet)
+	col := TitleToNumber(strings.ToUpper(column)) + 1
+	visible := true
+	if xlsx.Cols == nil {
+		return visible
+	}
+	for c := range xlsx.Cols.Col {
+		if xlsx.Cols.Col[c].Min <= col && col <= xlsx.Cols.Col[c].Max {
+			visible = !xlsx.Cols.Col[c].Hidden
+		}
+	}
+	return visible
+}
+
+// SetColVisible provides a function to set visible of a single column by given
+// worksheet name and column name. For example, hide column D in Sheet1:
+//
+//    xlsx.SetColVisible("Sheet1", "D", false)
+//
+func (f *File) SetColVisible(sheet, column string, visible bool) {
+	xlsx := f.workSheetReader(sheet)
+	c := TitleToNumber(strings.ToUpper(column)) + 1
+	col := xlsxCol{
+		Min:         c,
+		Max:         c,
+		Hidden:      !visible,
+		CustomWidth: true,
+	}
+	if xlsx.Cols == nil {
+		cols := xlsxCols{}
+		cols.Col = append(cols.Col, col)
+		xlsx.Cols = &cols
+		return
+	}
+	for v := range xlsx.Cols.Col {
+		if xlsx.Cols.Col[v].Min <= c && c <= xlsx.Cols.Col[v].Max {
+			col = xlsx.Cols.Col[v]
+		}
+	}
+	col.Min = c
+	col.Max = c
+	col.Hidden = !visible
+	col.CustomWidth = true
+	xlsx.Cols.Col = append(xlsx.Cols.Col, col)
+}
+
+// GetColOutlineLevel provides a function to get outline level of a single
+// column by given worksheet name and column name. For example, get outline
+// level of column D in Sheet1:
+//
+//    xlsx.GetColOutlineLevel("Sheet1", "D")
+//
+func (f *File) GetColOutlineLevel(sheet, column string) uint8 {
+	xlsx := f.workSheetReader(sheet)
+	col := TitleToNumber(strings.ToUpper(column)) + 1
+	level := uint8(0)
+	if xlsx.Cols == nil {
+		return level
+	}
+	for c := range xlsx.Cols.Col {
+		if xlsx.Cols.Col[c].Min <= col && col <= xlsx.Cols.Col[c].Max {
+			level = xlsx.Cols.Col[c].OutlineLevel
+		}
+	}
+	return level
+}
+
+// SetColOutlineLevel provides a function to set outline level of a single
+// column by given worksheet name and column name. For example, set outline
+// level of column D in Sheet1 to 2:
+//
+//    xlsx.SetColOutlineLevel("Sheet1", "D", 2)
+//
+func (f *File) SetColOutlineLevel(sheet, column string, level uint8) {
+	xlsx := f.workSheetReader(sheet)
+	c := TitleToNumber(strings.ToUpper(column)) + 1
+	col := xlsxCol{
+		Min:          c,
+		Max:          c,
+		OutlineLevel: level,
+		CustomWidth:  true,
+	}
+	if xlsx.Cols == nil {
+		cols := xlsxCols{}
+		cols.Col = append(cols.Col, col)
+		xlsx.Cols = &cols
+		return
+	}
+	for v := range xlsx.Cols.Col {
+		if xlsx.Cols.Col[v].Min <= c && c <= xlsx.Cols.Col[v].Max {
+			col = xlsx.Cols.Col[v]
+		}
+	}
+	col.Min = c
+	col.Max = c
+	col.OutlineLevel = level
+	col.CustomWidth = true
+	xlsx.Cols.Col = append(xlsx.Cols.Col, col)
+}
+
+// SetColWidth provides a function to set the width of a single column or
+// multiple columns. For example:
+//
+//    xlsx := excelize.NewFile()
+//    xlsx.SetColWidth("Sheet1", "A", "H", 20)
+//    err := xlsx.Save()
+//    if err != nil {
+//        fmt.Println(err)
+//    }
+//
+func (f *File) SetColWidth(sheet, startcol, endcol string, width float64) {
+	min := TitleToNumber(strings.ToUpper(startcol)) + 1
+	max := TitleToNumber(strings.ToUpper(endcol)) + 1
+	if min > max {
+		min, max = max, min
+	}
+	xlsx := f.workSheetReader(sheet)
+	col := xlsxCol{
+		Min:         min,
+		Max:         max,
+		Width:       width,
+		CustomWidth: true,
+	}
+	if xlsx.Cols != nil {
+		xlsx.Cols.Col = append(xlsx.Cols.Col, col)
+	} else {
+		cols := xlsxCols{}
+		cols.Col = append(cols.Col, col)
+		xlsx.Cols = &cols
+	}
+}
+
+// positionObjectPixels calculate the vertices that define the position of a
+// graphical object within the worksheet in pixels.
+//
+//          +------------+------------+
+//          |     A      |      B     |
+//    +-----+------------+------------+
+//    |     |(x1,y1)     |            |
+//    |  1  |(A1)._______|______      |
+//    |     |    |              |     |
+//    |     |    |              |     |
+//    +-----+----|    OBJECT    |-----+
+//    |     |    |              |     |
+//    |  2  |    |______________.     |
+//    |     |            |        (B2)|
+//    |     |            |     (x2,y2)|
+//    +-----+------------+------------+
+//
+// Example of an object that covers some of the area from cell A1 to B2.
+//
+// Based on the width and height of the object we need to calculate 8 vars:
+//
+//    colStart, rowStart, colEnd, rowEnd, x1, y1, x2, y2.
+//
+// We also calculate the absolute x and y position of the top left vertex of
+// the object. This is required for images.
+//
+// The width and height of the cells that the object occupies can be
+// variable and have to be taken into account.
+//
+// The values of col_start and row_start are passed in from the calling
+// function. The values of col_end and row_end are calculated by
+// subtracting the width and height of the object from the width and
+// height of the underlying cells.
+//
+//    colStart        # Col containing upper left corner of object.
+//    x1              # Distance to left side of object.
+//
+//    rowStart        # Row containing top left corner of object.
+//    y1              # Distance to top of object.
+//
+//    colEnd          # Col containing lower right corner of object.
+//    x2              # Distance to right side of object.
+//
+//    rowEnd          # Row containing bottom right corner of object.
+//    y2              # Distance to bottom of object.
+//
+//    width           # Width of object frame.
+//    height          # Height of object frame.
+//
+//    xAbs            # Absolute distance to left side of object.
+//    yAbs            # Absolute distance to top side of object.
+//
+func (f *File) positionObjectPixels(sheet string, colStart, rowStart, x1, y1, width, height int) (int, int, int, int, int, int, int, int) {
+	xAbs := 0
+	yAbs := 0
+
+	// Calculate the absolute x offset of the top-left vertex.
+	for colID := 1; colID <= colStart; colID++ {
+		xAbs += f.getColWidth(sheet, colID)
+	}
+	xAbs += x1
+
+	// Calculate the absolute y offset of the top-left vertex.
+	// Store the column change to allow optimisations.
+	for rowID := 1; rowID <= rowStart; rowID++ {
+		yAbs += f.getRowHeight(sheet, rowID)
+	}
+	yAbs += y1
+
+	// Adjust start column for offsets that are greater than the col width.
+	for x1 >= f.getColWidth(sheet, colStart) {
+		x1 -= f.getColWidth(sheet, colStart)
+		colStart++
+	}
+
+	// Adjust start row for offsets that are greater than the row height.
+	for y1 >= f.getRowHeight(sheet, rowStart) {
+		y1 -= f.getRowHeight(sheet, rowStart)
+		rowStart++
+	}
+
+	// Initialise end cell to the same as the start cell.
+	colEnd := colStart
+	rowEnd := rowStart
+
+	width += x1
+	height += y1
+
+	// Subtract the underlying cell widths to find end cell of the object.
+	for width >= f.getColWidth(sheet, colEnd) {
+		colEnd++
+		width -= f.getColWidth(sheet, colEnd)
+	}
+
+	// Subtract the underlying cell heights to find end cell of the object.
+	for height >= f.getRowHeight(sheet, rowEnd) {
+		rowEnd++
+		height -= f.getRowHeight(sheet, rowEnd)
+	}
+
+	// The end vertices are whatever is left from the width and height.
+	x2 := width
+	y2 := height
+	return colStart, rowStart, xAbs, yAbs, colEnd, rowEnd, x2, y2
+}
+
+// getColWidth provides a function to get column width in pixels by given
+// sheet name and column index.
+func (f *File) getColWidth(sheet string, col int) int {
+	xlsx := f.workSheetReader(sheet)
+	if xlsx.Cols != nil {
+		var width float64
+		for _, v := range xlsx.Cols.Col {
+			if v.Min <= col && col <= v.Max {
+				width = v.Width
+			}
+		}
+		if width != 0 {
+			return int(convertColWidthToPixels(width))
+		}
+	}
+	// Optimisation for when the column widths haven't changed.
+	return int(defaultColWidthPixels)
+}
+
+// GetColWidth provides a function to get column width by given worksheet name
+// and column index.
+func (f *File) GetColWidth(sheet, column string) float64 {
+	col := TitleToNumber(strings.ToUpper(column)) + 1
+	xlsx := f.workSheetReader(sheet)
+	if xlsx.Cols != nil {
+		var width float64
+		for _, v := range xlsx.Cols.Col {
+			if v.Min <= col && col <= v.Max {
+				width = v.Width
+			}
+		}
+		if width != 0 {
+			return width
+		}
+	}
+	// Optimisation for when the column widths haven't changed.
+	return defaultColWidthPixels
+}
+
+// InsertCol provides a function to insert a new column before given column
+// index. For example, create a new column before column C in Sheet1:
+//
+//    xlsx.InsertCol("Sheet1", "C")
+//
+func (f *File) InsertCol(sheet, column string) {
+	col := TitleToNumber(strings.ToUpper(column))
+	f.adjustHelper(sheet, col, -1, 1)
+}
+
+// RemoveCol provides a function to remove single column by given worksheet
+// name and column index. For example, remove column C in Sheet1:
+//
+//    xlsx.RemoveCol("Sheet1", "C")
+//
+func (f *File) RemoveCol(sheet, column string) {
+	xlsx := f.workSheetReader(sheet)
+	for r := range xlsx.SheetData.Row {
+		for k, v := range xlsx.SheetData.Row[r].C {
+			axis := v.R
+			col := string(strings.Map(letterOnlyMapF, axis))
+			if col == column {
+				xlsx.SheetData.Row[r].C = append(xlsx.SheetData.Row[r].C[:k], xlsx.SheetData.Row[r].C[k+1:]...)
+			}
+		}
+	}
+	col := TitleToNumber(strings.ToUpper(column))
+	f.adjustHelper(sheet, col, -1, -1)
+}
+
+// Completion column element tags of XML in a sheet.
+func completeCol(xlsx *xlsxWorksheet, row, cell int) {
+	buffer := bytes.Buffer{}
+	for r := range xlsx.SheetData.Row {
+		if len(xlsx.SheetData.Row[r].C) < cell {
+			start := len(xlsx.SheetData.Row[r].C)
+			for iii := start; iii < cell; iii++ {
+				buffer.WriteString(ToAlphaString(iii))
+				buffer.WriteString(strconv.Itoa(r + 1))
+				xlsx.SheetData.Row[r].C = append(xlsx.SheetData.Row[r].C, xlsxC{
+					R: buffer.String(),
+				})
+				buffer.Reset()
+			}
+		}
+	}
+}
+
+// convertColWidthToPixels provieds function to convert the width of a cell
+// from user's units to pixels. Excel rounds the column width to the nearest
+// pixel. If the width hasn't been set by the user we use the default value.
+// If the column is hidden it has a value of zero.
+func convertColWidthToPixels(width float64) float64 {
+	var padding float64 = 5
+	var pixels float64
+	var maxDigitWidth float64 = 7
+	if width == 0 {
+		return pixels
+	}
+	if width < 1 {
+		pixels = (width * 12) + 0.5
+		return math.Ceil(pixels)
+	}
+	pixels = (width*maxDigitWidth + 0.5) + padding
+	return math.Ceil(pixels)
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/comment.go

@@ -0,0 +1,251 @@
+package excelize
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// parseFormatCommentsSet provides a function to parse the format settings of
+// the comment with default value.
+func parseFormatCommentsSet(formatSet string) (*formatComment, error) {
+	format := formatComment{
+		Author: "Author:",
+		Text:   " ",
+	}
+	err := json.Unmarshal([]byte(formatSet), &format)
+	return &format, err
+}
+
+// GetComments retrieves all comments and returns a map of worksheet name to
+// the worksheet comments.
+func (f *File) GetComments() (comments map[string]*xlsxComments) {
+	comments = map[string]*xlsxComments{}
+	for n := range f.sheetMap {
+		commentID := f.GetSheetIndex(n)
+		commentsXML := "xl/comments" + strconv.Itoa(commentID) + ".xml"
+		c, ok := f.XLSX[commentsXML]
+		if ok {
+			d := xlsxComments{}
+			xml.Unmarshal([]byte(c), &d)
+			comments[n] = &d
+		}
+	}
+	return
+}
+
+// AddComment provides the method to add comment in a sheet by given worksheet
+// index, cell and format set (such as author and text). Note that the max
+// author length is 255 and the max text length is 32512. For example, add a
+// comment in Sheet1!$A$30:
+//
+//    xlsx.AddComment("Sheet1", "A30", `{"author":"Excelize: ","text":"This is a comment."}`)
+//
+func (f *File) AddComment(sheet, cell, format string) error {
+	formatSet, err := parseFormatCommentsSet(format)
+	if err != nil {
+		return err
+	}
+	// Read sheet data.
+	xlsx := f.workSheetReader(sheet)
+	commentID := f.countComments() + 1
+	drawingVML := "xl/drawings/vmlDrawing" + strconv.Itoa(commentID) + ".vml"
+	sheetRelationshipsComments := "../comments" + strconv.Itoa(commentID) + ".xml"
+	sheetRelationshipsDrawingVML := "../drawings/vmlDrawing" + strconv.Itoa(commentID) + ".vml"
+	if xlsx.LegacyDrawing != nil {
+		// The worksheet already has a comments relationships, use the relationships drawing ../drawings/vmlDrawing%d.vml.
+		sheetRelationshipsDrawingVML = f.getSheetRelationshipsTargetByID(sheet, xlsx.LegacyDrawing.RID)
+		commentID, _ = strconv.Atoi(strings.TrimSuffix(strings.TrimPrefix(sheetRelationshipsDrawingVML, "../drawings/vmlDrawing"), ".vml"))
+		drawingVML = strings.Replace(sheetRelationshipsDrawingVML, "..", "xl", -1)
+	} else {
+		// Add first comment for given sheet.
+		rID := f.addSheetRelationships(sheet, SourceRelationshipDrawingVML, sheetRelationshipsDrawingVML, "")
+		f.addSheetRelationships(sheet, SourceRelationshipComments, sheetRelationshipsComments, "")
+		f.addSheetLegacyDrawing(sheet, rID)
+	}
+	commentsXML := "xl/comments" + strconv.Itoa(commentID) + ".xml"
+	f.addComment(commentsXML, cell, formatSet)
+	var colCount int
+	for i, l := range strings.Split(formatSet.Text, "\n") {
+		if ll := len(l); ll > colCount {
+			if i == 0 {
+				ll += len(formatSet.Author)
+			}
+			colCount = ll
+		}
+	}
+	f.addDrawingVML(commentID, drawingVML, cell, strings.Count(formatSet.Text, "\n")+1, colCount)
+	f.addContentTypePart(commentID, "comments")
+	return err
+}
+
+// addDrawingVML provides a function to create comment as
+// xl/drawings/vmlDrawing%d.vml by given commit ID and cell.
+func (f *File) addDrawingVML(commentID int, drawingVML, cell string, lineCount, colCount int) {
+	col := string(strings.Map(letterOnlyMapF, cell))
+	row, _ := strconv.Atoi(strings.Map(intOnlyMapF, cell))
+	xAxis := row - 1
+	yAxis := TitleToNumber(col)
+	vml := vmlDrawing{
+		XMLNSv:  "urn:schemas-microsoft-com:vml",
+		XMLNSo:  "urn:schemas-microsoft-com:office:office",
+		XMLNSx:  "urn:schemas-microsoft-com:office:excel",
+		XMLNSmv: "http://macVmlSchemaUri",
+		Shapelayout: &xlsxShapelayout{
+			Ext: "edit",
+			IDmap: &xlsxIDmap{
+				Ext:  "edit",
+				Data: commentID,
+			},
+		},
+		Shapetype: &xlsxShapetype{
+			ID:        "_x0000_t202",
+			Coordsize: "21600,21600",
+			Spt:       202,
+			Path:      "m0,0l0,21600,21600,21600,21600,0xe",
+			Stroke: &xlsxStroke{
+				Joinstyle: "miter",
+			},
+			VPath: &vPath{
+				Gradientshapeok: "t",
+				Connecttype:     "miter",
+			},
+		},
+	}
+	sp := encodeShape{
+		Fill: &vFill{
+			Color2: "#fbfe82",
+			Angle:  -180,
+			Type:   "gradient",
+			Fill: &oFill{
+				Ext:  "view",
+				Type: "gradientUnscaled",
+			},
+		},
+		Shadow: &vShadow{
+			On:       "t",
+			Color:    "black",
+			Obscured: "t",
+		},
+		Path: &vPath{
+			Connecttype: "none",
+		},
+		Textbox: &vTextbox{
+			Style: "mso-direction-alt:auto",
+			Div: &xlsxDiv{
+				Style: "text-align:left",
+			},
+		},
+		ClientData: &xClientData{
+			ObjectType: "Note",
+			Anchor: fmt.Sprintf(
+				"%d, 23, %d, 0, %d, %d, %d, 5",
+				1+yAxis, 1+xAxis, 2+yAxis+lineCount, colCount+yAxis, 2+xAxis+lineCount),
+			AutoFill: "True",
+			Row:      xAxis,
+			Column:   yAxis,
+		},
+	}
+	s, _ := xml.Marshal(sp)
+	shape := xlsxShape{
+		ID:          "_x0000_s1025",
+		Type:        "#_x0000_t202",
+		Style:       "position:absolute;73.5pt;width:108pt;height:59.25pt;z-index:1;visibility:hidden",
+		Fillcolor:   "#fbf6d6",
+		Strokecolor: "#edeaa1",
+		Val:         string(s[13 : len(s)-14]),
+	}
+	c, ok := f.XLSX[drawingVML]
+	if ok {
+		d := decodeVmlDrawing{}
+		_ = xml.Unmarshal([]byte(c), &d)
+		for _, v := range d.Shape {
+			s := xlsxShape{
+				ID:          "_x0000_s1025",
+				Type:        "#_x0000_t202",
+				Style:       "position:absolute;73.5pt;width:108pt;height:59.25pt;z-index:1;visibility:hidden",
+				Fillcolor:   "#fbf6d6",
+				Strokecolor: "#edeaa1",
+				Val:         v.Val,
+			}
+			vml.Shape = append(vml.Shape, s)
+		}
+	}
+	vml.Shape = append(vml.Shape, shape)
+	v, _ := xml.Marshal(vml)
+	f.XLSX[drawingVML] = v
+}
+
+// addComment provides a function to create chart as xl/comments%d.xml by
+// given cell and format sets.
+func (f *File) addComment(commentsXML, cell string, formatSet *formatComment) {
+	a := formatSet.Author
+	t := formatSet.Text
+	if len(a) > 255 {
+		a = a[0:255]
+	}
+	if len(t) > 32512 {
+		t = t[0:32512]
+	}
+	comments := xlsxComments{
+		Authors: []xlsxAuthor{
+			{
+				Author: formatSet.Author,
+			},
+		},
+	}
+	cmt := xlsxComment{
+		Ref:      cell,
+		AuthorID: 0,
+		Text: xlsxText{
+			R: []xlsxR{
+				{
+					RPr: &xlsxRPr{
+						B:  " ",
+						Sz: &attrValFloat{Val: 9},
+						Color: &xlsxColor{
+							Indexed: 81,
+						},
+						RFont:  &attrValString{Val: "Calibri"},
+						Family: &attrValInt{Val: 2},
+					},
+					T: a,
+				},
+				{
+					RPr: &xlsxRPr{
+						Sz: &attrValFloat{Val: 9},
+						Color: &xlsxColor{
+							Indexed: 81,
+						},
+						RFont:  &attrValString{Val: "Calibri"},
+						Family: &attrValInt{Val: 2},
+					},
+					T: t,
+				},
+			},
+		},
+	}
+	c, ok := f.XLSX[commentsXML]
+	if ok {
+		d := xlsxComments{}
+		_ = xml.Unmarshal([]byte(c), &d)
+		comments.CommentList.Comment = append(comments.CommentList.Comment, d.CommentList.Comment...)
+	}
+	comments.CommentList.Comment = append(comments.CommentList.Comment, cmt)
+	v, _ := xml.Marshal(comments)
+	f.saveFileList(commentsXML, v)
+}
+
+// countComments provides a function to get comments files count storage in
+// the folder xl.
+func (f *File) countComments() int {
+	count := 0
+	for k := range f.XLSX {
+		if strings.Contains(k, "xl/comments") {
+			count++
+		}
+	}
+	return count
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/date.go

@@ -0,0 +1,141 @@
+package excelize
+
+import (
+	"math"
+	"time"
+)
+
+// timeLocationUTC defined the UTC time location.
+var timeLocationUTC, _ = time.LoadLocation("UTC")
+
+// timeToUTCTime provides a function to convert time to UTC time.
+func timeToUTCTime(t time.Time) time.Time {
+	return time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), timeLocationUTC)
+}
+
+// timeToExcelTime provides a function to convert time to Excel time.
+func timeToExcelTime(t time.Time) float64 {
+	// TODO in future this should probably also handle date1904 and like TimeFromExcelTime
+	var excelTime float64
+	var deltaDays int64
+	excelTime = 0
+	deltaDays = 290 * 364
+	// check if UnixNano would be out of int64 range
+	for t.Unix() > deltaDays*24*60*60 {
+		// reduce by aprox. 290 years, which is max for int64 nanoseconds
+		delta := time.Duration(deltaDays) * 24 * time.Hour
+		excelTime = excelTime + float64(deltaDays)
+		t = t.Add(-delta)
+	}
+	// finally add remainder of UnixNano to keep nano precision
+	// and 25569 which is days between 1900 and 1970
+	return excelTime + float64(t.UnixNano())/8.64e13 + 25569.0
+}
+
+// shiftJulianToNoon provides a function to process julian date to noon.
+func shiftJulianToNoon(julianDays, julianFraction float64) (float64, float64) {
+	switch {
+	case -0.5 < julianFraction && julianFraction < 0.5:
+		julianFraction += 0.5
+	case julianFraction >= 0.5:
+		julianDays++
+		julianFraction -= 0.5
+	case julianFraction <= -0.5:
+		julianDays--
+		julianFraction += 1.5
+	}
+	return julianDays, julianFraction
+}
+
+// fractionOfADay provides a function to return the integer values for hour,
+// minutes, seconds and nanoseconds that comprised a given fraction of a day.
+// values would round to 1 us.
+func fractionOfADay(fraction float64) (hours, minutes, seconds, nanoseconds int) {
+
+	const (
+		c1us  = 1e3
+		c1s   = 1e9
+		c1day = 24 * 60 * 60 * c1s
+	)
+
+	frac := int64(c1day*fraction + c1us/2)
+	nanoseconds = int((frac%c1s)/c1us) * c1us
+	frac /= c1s
+	seconds = int(frac % 60)
+	frac /= 60
+	minutes = int(frac % 60)
+	hours = int(frac / 60)
+	return
+}
+
+// julianDateToGregorianTime provides a function to convert julian date to
+// gregorian time.
+func julianDateToGregorianTime(part1, part2 float64) time.Time {
+	part1I, part1F := math.Modf(part1)
+	part2I, part2F := math.Modf(part2)
+	julianDays := part1I + part2I
+	julianFraction := part1F + part2F
+	julianDays, julianFraction = shiftJulianToNoon(julianDays, julianFraction)
+	day, month, year := doTheFliegelAndVanFlandernAlgorithm(int(julianDays))
+	hours, minutes, seconds, nanoseconds := fractionOfADay(julianFraction)
+	return time.Date(year, time.Month(month), day, hours, minutes, seconds, nanoseconds, time.UTC)
+}
+
+// By this point generations of programmers have repeated the algorithm sent
+// to the editor of "Communications of the ACM" in 1968 (published in CACM,
+// volume 11, number 10, October 1968, p.657). None of those programmers seems
+// to have found it necessary to explain the constants or variable names set
+// out by Henry F. Fliegel and Thomas C. Van Flandern.  Maybe one day I'll buy
+// that jounal and expand an explanation here - that day is not today.
+func doTheFliegelAndVanFlandernAlgorithm(jd int) (day, month, year int) {
+	l := jd + 68569
+	n := (4 * l) / 146097
+	l = l - (146097*n+3)/4
+	i := (4000 * (l + 1)) / 1461001
+	l = l - (1461*i)/4 + 31
+	j := (80 * l) / 2447
+	d := l - (2447*j)/80
+	l = j / 11
+	m := j + 2 - (12 * l)
+	y := 100*(n-49) + i + l
+	return d, m, y
+}
+
+// timeFromExcelTime provides a function to convert an excelTime
+// representation (stored as a floating point number) to a time.Time.
+func timeFromExcelTime(excelTime float64, date1904 bool) time.Time {
+	const MDD int64 = 106750 // Max time.Duration Days, aprox. 290 years
+	var date time.Time
+	var intPart = int64(excelTime)
+	// Excel uses Julian dates prior to March 1st 1900, and Gregorian
+	// thereafter.
+	if intPart <= 61 {
+		const OFFSET1900 = 15018.0
+		const OFFSET1904 = 16480.0
+		const MJD0 float64 = 2400000.5
+		var date time.Time
+		if date1904 {
+			date = julianDateToGregorianTime(MJD0, excelTime+OFFSET1904)
+		} else {
+			date = julianDateToGregorianTime(MJD0, excelTime+OFFSET1900)
+		}
+		return date
+	}
+	var floatPart = excelTime - float64(intPart)
+	var dayNanoSeconds float64 = 24 * 60 * 60 * 1000 * 1000 * 1000
+	if date1904 {
+		date = time.Date(1904, 1, 1, 0, 0, 0, 0, time.UTC)
+	} else {
+		date = time.Date(1899, 12, 30, 0, 0, 0, 0, time.UTC)
+	}
+
+	// Duration is limited to aprox. 290 years
+	for intPart > MDD {
+		durationDays := time.Duration(MDD) * time.Hour * 24
+		date = date.Add(durationDays)
+		intPart = intPart - MDD
+	}
+	durationDays := time.Duration(intPart) * time.Hour * 24
+	durationPart := time.Duration(dayNanoSeconds * floatPart)
+	return date.Add(durationDays).Add(durationPart)
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/excelize.go

@@ -0,0 +1,403 @@
+package excelize
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/xml"
+	"io"
+	"io/ioutil"
+	"os"
+	"strconv"
+	"strings"
+)
+
+// File define a populated XLSX file struct.
+type File struct {
+	checked       map[string]bool
+	sheetMap      map[string]string
+	ContentTypes  *xlsxTypes
+	Path          string
+	SharedStrings *xlsxSST
+	Sheet         map[string]*xlsxWorksheet
+	SheetCount    int
+	Styles        *xlsxStyleSheet
+	Theme         *xlsxTheme
+	WorkBook      *xlsxWorkbook
+	WorkBookRels  *xlsxWorkbookRels
+	XLSX          map[string][]byte
+}
+
+// OpenFile take the name of an XLSX file and returns a populated XLSX file
+// struct for it.
+func OpenFile(filename string) (*File, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+	f, err := OpenReader(file)
+	if err != nil {
+		return nil, err
+	}
+	f.Path = filename
+	return f, nil
+}
+
+// OpenReader take an io.Reader and return a populated XLSX file.
+func OpenReader(r io.Reader) (*File, error) {
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		return nil, err
+	}
+
+	zr, err := zip.NewReader(bytes.NewReader(b), int64(len(b)))
+	if err != nil {
+		return nil, err
+	}
+
+	file, sheetCount, err := ReadZipReader(zr)
+	if err != nil {
+		return nil, err
+	}
+	f := &File{
+		checked:    make(map[string]bool),
+		Sheet:      make(map[string]*xlsxWorksheet),
+		SheetCount: sheetCount,
+		XLSX:       file,
+	}
+	f.sheetMap = f.getSheetMap()
+	f.Styles = f.stylesReader()
+	f.Theme = f.themeReader()
+	return f, nil
+}
+
+// setDefaultTimeStyle provides a function to set default numbers format for
+// time.Time type cell value by given worksheet name, cell coordinates and
+// number format code.
+func (f *File) setDefaultTimeStyle(sheet, axis string, format int) {
+	if f.GetCellStyle(sheet, axis) == 0 {
+		style, _ := f.NewStyle(`{"number_format": ` + strconv.Itoa(format) + `}`)
+		f.SetCellStyle(sheet, axis, axis, style)
+	}
+}
+
+// workSheetReader provides a function to get the pointer to the structure
+// after deserialization by given worksheet name.
+func (f *File) workSheetReader(sheet string) *xlsxWorksheet {
+	name, ok := f.sheetMap[trimSheetName(sheet)]
+	if !ok {
+		name = "xl/worksheets/" + strings.ToLower(sheet) + ".xml"
+	}
+	if f.Sheet[name] == nil {
+		var xlsx xlsxWorksheet
+		_ = xml.Unmarshal(f.readXML(name), &xlsx)
+		if f.checked == nil {
+			f.checked = make(map[string]bool)
+		}
+		ok := f.checked[name]
+		if !ok {
+			checkSheet(&xlsx)
+			checkRow(&xlsx)
+			f.checked[name] = true
+		}
+		f.Sheet[name] = &xlsx
+	}
+	return f.Sheet[name]
+}
+
+// checkSheet provides a function to fill each row element and make that is
+// continuous in a worksheet of XML.
+func checkSheet(xlsx *xlsxWorksheet) {
+	row := len(xlsx.SheetData.Row)
+	if row >= 1 {
+		lastRow := xlsx.SheetData.Row[row-1].R
+		if lastRow >= row {
+			row = lastRow
+		}
+	}
+	sheetData := xlsxSheetData{}
+	existsRows := map[int]int{}
+	for k := range xlsx.SheetData.Row {
+		existsRows[xlsx.SheetData.Row[k].R] = k
+	}
+	for i := 0; i < row; i++ {
+		_, ok := existsRows[i+1]
+		if ok {
+			sheetData.Row = append(sheetData.Row, xlsx.SheetData.Row[existsRows[i+1]])
+		} else {
+			sheetData.Row = append(sheetData.Row, xlsxRow{
+				R: i + 1,
+			})
+		}
+	}
+	xlsx.SheetData = sheetData
+}
+
+// replaceWorkSheetsRelationshipsNameSpaceBytes provides a function to replace
+// xl/worksheets/sheet%d.xml XML tags to self-closing for compatible Microsoft
+// Office Excel 2007.
+func replaceWorkSheetsRelationshipsNameSpaceBytes(workbookMarshal []byte) []byte {
+	var oldXmlns = []byte(`<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">`)
+	var newXmlns = []byte(`<worksheet xr:uid="{00000000-0001-0000-0000-000000000000}" xmlns:xr3="http://schemas.microsoft.com/office/spreadsheetml/2016/revision3" xmlns:xr2="http://schemas.microsoft.com/office/spreadsheetml/2015/revision2" xmlns:xr="http://schemas.microsoft.com/office/spreadsheetml/2014/revision" xmlns:x14="http://schemas.microsoft.com/office/spreadsheetml/2009/9/main" xmlns:x14ac="http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac" mc:Ignorable="x14ac xr xr2 xr3" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:mx="http://schemas.microsoft.com/office/mac/excel/2008/main" xmlns:mv="urn:schemas-microsoft-com:mac:vml" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">`)
+	workbookMarshal = bytes.Replace(workbookMarshal, oldXmlns, newXmlns, -1)
+	return workbookMarshal
+}
+
+// UpdateLinkedValue fix linked values within a spreadsheet are not updating in
+// Office Excel 2007 and 2010. This function will be remove value tag when met a
+// cell have a linked value. Reference
+// https://social.technet.microsoft.com/Forums/office/en-US/e16bae1f-6a2c-4325-8013-e989a3479066/excel-2010-linked-cells-not-updating?forum=excel
+//
+// Notice: after open XLSX file Excel will be update linked value and generate
+// new value and will prompt save file or not.
+//
+// For example:
+//
+//    <row r="19" spans="2:2">
+//        <c r="B19">
+//            <f>SUM(Sheet2!D2,Sheet2!D11)</f>
+//            <v>100</v>
+//         </c>
+//    </row>
+//
+// to
+//
+//    <row r="19" spans="2:2">
+//        <c r="B19">
+//            <f>SUM(Sheet2!D2,Sheet2!D11)</f>
+//        </c>
+//    </row>
+//
+func (f *File) UpdateLinkedValue() {
+	for _, name := range f.GetSheetMap() {
+		xlsx := f.workSheetReader(name)
+		for indexR := range xlsx.SheetData.Row {
+			for indexC, col := range xlsx.SheetData.Row[indexR].C {
+				if col.F != nil && col.V != "" {
+					xlsx.SheetData.Row[indexR].C[indexC].V = ""
+					xlsx.SheetData.Row[indexR].C[indexC].T = ""
+				}
+			}
+		}
+	}
+}
+
+// adjustHelper provides a function to adjust rows and columns dimensions,
+// hyperlinks, merged cells and auto filter when inserting or deleting rows or
+// columns.
+//
+// sheet: Worksheet name that we're editing
+// column: Index number of the column we're inserting/deleting before
+// row: Index number of the row we're inserting/deleting before
+// offset: Number of rows/column to insert/delete negative values indicate deletion
+//
+// TODO: adjustPageBreaks, adjustComments, adjustDataValidations, adjustProtectedCells
+//
+func (f *File) adjustHelper(sheet string, column, row, offset int) {
+	xlsx := f.workSheetReader(sheet)
+	f.adjustRowDimensions(xlsx, row, offset)
+	f.adjustColDimensions(xlsx, column, offset)
+	f.adjustHyperlinks(sheet, column, row, offset)
+	f.adjustMergeCells(xlsx, column, row, offset)
+	f.adjustAutoFilter(xlsx, column, row, offset)
+	checkSheet(xlsx)
+	checkRow(xlsx)
+}
+
+// adjustColDimensions provides a function to update column dimensions when
+// inserting or deleting rows or columns.
+func (f *File) adjustColDimensions(xlsx *xlsxWorksheet, column, offset int) {
+	for i, r := range xlsx.SheetData.Row {
+		for k, v := range r.C {
+			axis := v.R
+			col := string(strings.Map(letterOnlyMapF, axis))
+			row, _ := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+			yAxis := TitleToNumber(col)
+			if yAxis >= column && column != -1 {
+				xlsx.SheetData.Row[i].C[k].R = ToAlphaString(yAxis+offset) + strconv.Itoa(row)
+			}
+		}
+	}
+}
+
+// adjustRowDimensions provides a function to update row dimensions when
+// inserting or deleting rows or columns.
+func (f *File) adjustRowDimensions(xlsx *xlsxWorksheet, rowIndex, offset int) {
+	if rowIndex == -1 {
+		return
+	}
+	for i, r := range xlsx.SheetData.Row {
+		if r.R >= rowIndex {
+			xlsx.SheetData.Row[i].R += offset
+			for k, v := range xlsx.SheetData.Row[i].C {
+				axis := v.R
+				col := string(strings.Map(letterOnlyMapF, axis))
+				row, _ := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+				xAxis := row + offset
+				xlsx.SheetData.Row[i].C[k].R = col + strconv.Itoa(xAxis)
+			}
+		}
+	}
+}
+
+// adjustHyperlinks provides a function to update hyperlinks when inserting or
+// deleting rows or columns.
+func (f *File) adjustHyperlinks(sheet string, column, rowIndex, offset int) {
+	xlsx := f.workSheetReader(sheet)
+
+	// order is important
+	if xlsx.Hyperlinks != nil && offset < 0 {
+		for i, v := range xlsx.Hyperlinks.Hyperlink {
+			axis := v.Ref
+			col := string(strings.Map(letterOnlyMapF, axis))
+			row, _ := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+			yAxis := TitleToNumber(col)
+			if row == rowIndex || yAxis == column {
+				f.deleteSheetRelationships(sheet, v.RID)
+				if len(xlsx.Hyperlinks.Hyperlink) > 1 {
+					xlsx.Hyperlinks.Hyperlink = append(xlsx.Hyperlinks.Hyperlink[:i], xlsx.Hyperlinks.Hyperlink[i+1:]...)
+				} else {
+					xlsx.Hyperlinks = nil
+				}
+			}
+		}
+	}
+
+	if xlsx.Hyperlinks != nil {
+		for i, v := range xlsx.Hyperlinks.Hyperlink {
+			axis := v.Ref
+			col := string(strings.Map(letterOnlyMapF, axis))
+			row, _ := strconv.Atoi(strings.Map(intOnlyMapF, axis))
+			xAxis := row + offset
+			yAxis := TitleToNumber(col)
+			if rowIndex != -1 && row >= rowIndex {
+				xlsx.Hyperlinks.Hyperlink[i].Ref = col + strconv.Itoa(xAxis)
+			}
+			if column != -1 && yAxis >= column {
+				xlsx.Hyperlinks.Hyperlink[i].Ref = ToAlphaString(yAxis+offset) + strconv.Itoa(row)
+			}
+		}
+	}
+}
+
+// adjustMergeCellsHelper provides a function to update merged cells when
+// inserting or deleting rows or columns.
+func (f *File) adjustMergeCellsHelper(xlsx *xlsxWorksheet, column, rowIndex, offset int) {
+	if xlsx.MergeCells != nil {
+		for k, v := range xlsx.MergeCells.Cells {
+			beg := strings.Split(v.Ref, ":")[0]
+			end := strings.Split(v.Ref, ":")[1]
+
+			begcol := string(strings.Map(letterOnlyMapF, beg))
+			begrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, beg))
+			begxAxis := begrow + offset
+			begyAxis := TitleToNumber(begcol)
+
+			endcol := string(strings.Map(letterOnlyMapF, end))
+			endrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, end))
+			endxAxis := endrow + offset
+			endyAxis := TitleToNumber(endcol)
+
+			if rowIndex != -1 {
+				if begrow > 1 && begrow >= rowIndex {
+					beg = begcol + strconv.Itoa(begxAxis)
+				}
+				if endrow > 1 && endrow >= rowIndex {
+					end = endcol + strconv.Itoa(endxAxis)
+				}
+			}
+
+			if column != -1 {
+				if begyAxis >= column {
+					beg = ToAlphaString(begyAxis+offset) + strconv.Itoa(endrow)
+				}
+				if endyAxis >= column {
+					end = ToAlphaString(endyAxis+offset) + strconv.Itoa(endrow)
+				}
+			}
+
+			xlsx.MergeCells.Cells[k].Ref = beg + ":" + end
+		}
+	}
+}
+
+// adjustMergeCells provides a function to update merged cells when inserting
+// or deleting rows or columns.
+func (f *File) adjustMergeCells(xlsx *xlsxWorksheet, column, rowIndex, offset int) {
+	f.adjustMergeCellsHelper(xlsx, column, rowIndex, offset)
+
+	if xlsx.MergeCells != nil && offset < 0 {
+		for k, v := range xlsx.MergeCells.Cells {
+			beg := strings.Split(v.Ref, ":")[0]
+			end := strings.Split(v.Ref, ":")[1]
+			if beg == end {
+				xlsx.MergeCells.Count += offset
+				if len(xlsx.MergeCells.Cells) > 1 {
+					xlsx.MergeCells.Cells = append(xlsx.MergeCells.Cells[:k], xlsx.MergeCells.Cells[k+1:]...)
+				} else {
+					xlsx.MergeCells = nil
+				}
+			}
+		}
+	}
+}
+
+// adjustAutoFilter provides a function to update the auto filter when
+// inserting or deleting rows or columns.
+func (f *File) adjustAutoFilter(xlsx *xlsxWorksheet, column, rowIndex, offset int) {
+	f.adjustAutoFilterHelper(xlsx, column, rowIndex, offset)
+
+	if xlsx.AutoFilter != nil {
+		beg := strings.Split(xlsx.AutoFilter.Ref, ":")[0]
+		end := strings.Split(xlsx.AutoFilter.Ref, ":")[1]
+
+		begcol := string(strings.Map(letterOnlyMapF, beg))
+		begrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, beg))
+		begxAxis := begrow + offset
+
+		endcol := string(strings.Map(letterOnlyMapF, end))
+		endrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, end))
+		endxAxis := endrow + offset
+		endyAxis := TitleToNumber(endcol)
+
+		if rowIndex != -1 {
+			if begrow >= rowIndex {
+				beg = begcol + strconv.Itoa(begxAxis)
+			}
+			if endrow >= rowIndex {
+				end = endcol + strconv.Itoa(endxAxis)
+			}
+		}
+
+		if column != -1 && endyAxis >= column {
+			end = ToAlphaString(endyAxis+offset) + strconv.Itoa(endrow)
+		}
+		xlsx.AutoFilter.Ref = beg + ":" + end
+	}
+}
+
+// adjustAutoFilterHelper provides a function to update the auto filter when
+// inserting or deleting rows or columns.
+func (f *File) adjustAutoFilterHelper(xlsx *xlsxWorksheet, column, rowIndex, offset int) {
+	if xlsx.AutoFilter != nil {
+		beg := strings.Split(xlsx.AutoFilter.Ref, ":")[0]
+		end := strings.Split(xlsx.AutoFilter.Ref, ":")[1]
+
+		begcol := string(strings.Map(letterOnlyMapF, beg))
+		begrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, beg))
+		begyAxis := TitleToNumber(begcol)
+
+		endcol := string(strings.Map(letterOnlyMapF, end))
+		endyAxis := TitleToNumber(endcol)
+		endrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, end))
+
+		if (begrow == rowIndex && offset < 0) || (column == begyAxis && column == endyAxis) {
+			xlsx.AutoFilter = nil
+			for i, r := range xlsx.SheetData.Row {
+				if begrow < r.R && r.R <= endrow {
+					xlsx.SheetData.Row[i].Hidden = false
+				}
+			}
+		}
+	}
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/file.go

@@ -0,0 +1,93 @@
+package excelize
+
+import (
+	"archive/zip"
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+)
+
+// NewFile provides a function to create new file by default template. For
+// example:
+//
+//    xlsx := NewFile()
+//
+func NewFile() *File {
+	file := make(map[string][]byte)
+	file["_rels/.rels"] = []byte(XMLHeader + templateRels)
+	file["docProps/app.xml"] = []byte(XMLHeader + templateDocpropsApp)
+	file["docProps/core.xml"] = []byte(XMLHeader + templateDocpropsCore)
+	file["xl/_rels/workbook.xml.rels"] = []byte(XMLHeader + templateWorkbookRels)
+	file["xl/theme/theme1.xml"] = []byte(XMLHeader + templateTheme)
+	file["xl/worksheets/sheet1.xml"] = []byte(XMLHeader + templateSheet)
+	file["xl/styles.xml"] = []byte(XMLHeader + templateStyles)
+	file["xl/workbook.xml"] = []byte(XMLHeader + templateWorkbook)
+	file["[Content_Types].xml"] = []byte(XMLHeader + templateContentTypes)
+	f := &File{
+		sheetMap:   make(map[string]string),
+		Sheet:      make(map[string]*xlsxWorksheet),
+		SheetCount: 1,
+		XLSX:       file,
+	}
+	f.ContentTypes = f.contentTypesReader()
+	f.Styles = f.stylesReader()
+	f.WorkBook = f.workbookReader()
+	f.WorkBookRels = f.workbookRelsReader()
+	f.Sheet["xl/worksheets/sheet1.xml"] = f.workSheetReader("Sheet1")
+	f.sheetMap["Sheet1"] = "xl/worksheets/sheet1.xml"
+	f.Theme = f.themeReader()
+	return f
+}
+
+// Save provides a function to override the xlsx file with origin path.
+func (f *File) Save() error {
+	if f.Path == "" {
+		return fmt.Errorf("No path defined for file, consider File.WriteTo or File.Write")
+	}
+	return f.SaveAs(f.Path)
+}
+
+// SaveAs provides a function to create or update to an xlsx file at the
+// provided path.
+func (f *File) SaveAs(name string) error {
+	file, err := os.OpenFile(name, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0666)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	return f.Write(file)
+}
+
+// Write provides a function to write to an io.Writer.
+func (f *File) Write(w io.Writer) error {
+	_, err := f.WriteTo(w)
+	return err
+}
+
+// WriteTo implements io.WriterTo to write the file.
+func (f *File) WriteTo(w io.Writer) (int64, error) {
+	buf := new(bytes.Buffer)
+	zw := zip.NewWriter(buf)
+	f.contentTypesWriter()
+	f.workbookWriter()
+	f.workbookRelsWriter()
+	f.worksheetWriter()
+	f.styleSheetWriter()
+	for path, content := range f.XLSX {
+		fi, err := zw.Create(path)
+		if err != nil {
+			return 0, err
+		}
+		_, err = fi.Write(content)
+		if err != nil {
+			return 0, err
+		}
+	}
+	err := zw.Close()
+	if err != nil {
+		return 0, err
+	}
+
+	return buf.WriteTo(w)
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/hsl.go

@@ -0,0 +1,141 @@
+/*
+Copyright (c) 2012 Rodrigo Moraes. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+	 * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+	 * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+	 * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package excelize
+
+import (
+	"image/color"
+	"math"
+)
+
+// HSLModel converts any color.Color to a HSL color.
+var HSLModel = color.ModelFunc(hslModel)
+
+// HSL represents a cylindrical coordinate of points in an RGB color model.
+//
+// Values are in the range 0 to 1.
+type HSL struct {
+	H, S, L float64
+}
+
+// RGBA returns the alpha-premultiplied red, green, blue and alpha values
+// for the HSL.
+func (c HSL) RGBA() (uint32, uint32, uint32, uint32) {
+	r, g, b := HSLToRGB(c.H, c.S, c.L)
+	return uint32(r) * 0x101, uint32(g) * 0x101, uint32(b) * 0x101, 0xffff
+}
+
+// hslModel converts a color.Color to HSL.
+func hslModel(c color.Color) color.Color {
+	if _, ok := c.(HSL); ok {
+		return c
+	}
+	r, g, b, _ := c.RGBA()
+	h, s, l := RGBToHSL(uint8(r>>8), uint8(g>>8), uint8(b>>8))
+	return HSL{h, s, l}
+}
+
+// RGBToHSL converts an RGB triple to a HSL triple.
+func RGBToHSL(r, g, b uint8) (h, s, l float64) {
+	fR := float64(r) / 255
+	fG := float64(g) / 255
+	fB := float64(b) / 255
+	max := math.Max(math.Max(fR, fG), fB)
+	min := math.Min(math.Min(fR, fG), fB)
+	l = (max + min) / 2
+	if max == min {
+		// Achromatic.
+		h, s = 0, 0
+	} else {
+		// Chromatic.
+		d := max - min
+		if l > 0.5 {
+			s = d / (2.0 - max - min)
+		} else {
+			s = d / (max + min)
+		}
+		switch max {
+		case fR:
+			h = (fG - fB) / d
+			if fG < fB {
+				h += 6
+			}
+		case fG:
+			h = (fB-fR)/d + 2
+		case fB:
+			h = (fR-fG)/d + 4
+		}
+		h /= 6
+	}
+	return
+}
+
+// HSLToRGB converts an HSL triple to a RGB triple.
+func HSLToRGB(h, s, l float64) (r, g, b uint8) {
+	var fR, fG, fB float64
+	if s == 0 {
+		fR, fG, fB = l, l, l
+	} else {
+		var q float64
+		if l < 0.5 {
+			q = l * (1 + s)
+		} else {
+			q = l + s - s*l
+		}
+		p := 2*l - q
+		fR = hueToRGB(p, q, h+1.0/3)
+		fG = hueToRGB(p, q, h)
+		fB = hueToRGB(p, q, h-1.0/3)
+	}
+	r = uint8((fR * 255) + 0.5)
+	g = uint8((fG * 255) + 0.5)
+	b = uint8((fB * 255) + 0.5)
+	return
+}
+
+// hueToRGB is a helper function for HSLToRGB.
+func hueToRGB(p, q, t float64) float64 {
+	if t < 0 {
+		t++
+	}
+	if t > 1 {
+		t--
+	}
+	if t < 1.0/6 {
+		return p + (q-p)*6*t
+	}
+	if t < 0.5 {
+		return q
+	}
+	if t < 2.0/3 {
+		return p + (q-p)*(2.0/3-t)*6
+	}
+	return p
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/lib.go

@@ -0,0 +1,176 @@
+package excelize
+
+import (
+	"archive/zip"
+	"bytes"
+	"io"
+	"log"
+	"math"
+	"unicode"
+)
+
+// ReadZipReader can be used to read an XLSX in memory without touching the
+// filesystem.
+func ReadZipReader(r *zip.Reader) (map[string][]byte, int, error) {
+	fileList := make(map[string][]byte)
+	worksheets := 0
+	for _, v := range r.File {
+		fileList[v.Name] = readFile(v)
+		if len(v.Name) > 18 {
+			if v.Name[0:19] == "xl/worksheets/sheet" {
+				worksheets++
+			}
+		}
+	}
+	return fileList, worksheets, nil
+}
+
+// readXML provides a function to read XML content as string.
+func (f *File) readXML(name string) []byte {
+	if content, ok := f.XLSX[name]; ok {
+		return content
+	}
+	return []byte{}
+}
+
+// saveFileList provides a function to update given file content in file list
+// of XLSX.
+func (f *File) saveFileList(name string, content []byte) {
+	newContent := make([]byte, 0, len(XMLHeader)+len(content))
+	newContent = append(newContent, []byte(XMLHeader)...)
+	newContent = append(newContent, content...)
+	f.XLSX[name] = newContent
+}
+
+// Read file content as string in a archive file.
+func readFile(file *zip.File) []byte {
+	rc, err := file.Open()
+	if err != nil {
+		log.Fatal(err)
+	}
+	buff := bytes.NewBuffer(nil)
+	_, _ = io.Copy(buff, rc)
+	rc.Close()
+	return buff.Bytes()
+}
+
+// ToAlphaString provides a function to convert integer to Excel sheet column
+// title. For example convert 36 to column title AK:
+//
+//     excelize.ToAlphaString(36)
+//
+func ToAlphaString(value int) string {
+	if value < 0 {
+		return ""
+	}
+	var ans string
+	i := value + 1
+	for i > 0 {
+		ans = string((i-1)%26+65) + ans
+		i = (i - 1) / 26
+	}
+	return ans
+}
+
+// TitleToNumber provides a function to convert Excel sheet column title to
+// int (this function doesn't do value check currently). For example convert
+// AK and ak to column title 36:
+//
+//    excelize.TitleToNumber("AK")
+//    excelize.TitleToNumber("ak")
+//
+func TitleToNumber(s string) int {
+	weight := 0.0
+	sum := 0
+	for i := len(s) - 1; i >= 0; i-- {
+		ch := int(s[i])
+		if int(s[i]) >= int('a') && int(s[i]) <= int('z') {
+			ch = int(s[i]) - 32
+		}
+		sum = sum + (ch-int('A')+1)*int(math.Pow(26, weight))
+		weight++
+	}
+	return sum - 1
+}
+
+// letterOnlyMapF is used in conjunction with strings.Map to return only the
+// characters A-Z and a-z in a string.
+func letterOnlyMapF(rune rune) rune {
+	switch {
+	case 'A' <= rune && rune <= 'Z':
+		return rune
+	case 'a' <= rune && rune <= 'z':
+		return rune - 32
+	}
+	return -1
+}
+
+// intOnlyMapF is used in conjunction with strings.Map to return only the
+// numeric portions of a string.
+func intOnlyMapF(rune rune) rune {
+	if rune >= 48 && rune < 58 {
+		return rune
+	}
+	return -1
+}
+
+// boolPtr returns a pointer to a bool with the given value.
+func boolPtr(b bool) *bool { return &b }
+
+// defaultTrue returns true if b is nil, or the pointed value.
+func defaultTrue(b *bool) bool {
+	if b == nil {
+		return true
+	}
+	return *b
+}
+
+// axisLowerOrEqualThan returns true if axis1 <= axis2 axis1/axis2 can be
+// either a column or a row axis, e.g. "A", "AAE", "42", "1", etc.
+//
+// For instance, the following comparisons are all true:
+//
+// "A" <= "B"
+// "A" <= "AA"
+// "B" <= "AA"
+// "BC" <= "ABCD" (in a XLSX sheet, the BC col comes before the ABCD col)
+// "1" <= "2"
+// "2" <= "11" (in a XLSX sheet, the row 2 comes before the row 11)
+// and so on
+func axisLowerOrEqualThan(axis1, axis2 string) bool {
+	if len(axis1) < len(axis2) {
+		return true
+	} else if len(axis1) > len(axis2) {
+		return false
+	} else {
+		return axis1 <= axis2
+	}
+}
+
+// getCellColRow returns the two parts of a cell identifier (its col and row)
+// as strings
+//
+// For instance:
+//
+// "C220" => "C", "220"
+// "aaef42" => "aaef", "42"
+// "" => "", ""
+func getCellColRow(cell string) (col, row string) {
+	for index, rune := range cell {
+		if unicode.IsDigit(rune) {
+			return cell[:index], cell[index:]
+		}
+
+	}
+
+	return cell, ""
+}
+
+// parseFormatSet provides a method to convert format string to []byte and
+// handle empty string.
+func parseFormatSet(formatSet string) []byte {
+	if formatSet != "" {
+		return []byte(formatSet)
+	}
+	return []byte("{}")
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/picture.go

@@ -0,0 +1,482 @@
+package excelize
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"errors"
+	"image"
+	"io/ioutil"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+// parseFormatPictureSet provides a function to parse the format settings of
+// the picture with default value.
+func parseFormatPictureSet(formatSet string) (*formatPicture, error) {
+	format := formatPicture{
+		FPrintsWithSheet: true,
+		FLocksWithSheet:  false,
+		NoChangeAspect:   false,
+		OffsetX:          0,
+		OffsetY:          0,
+		XScale:           1.0,
+		YScale:           1.0,
+	}
+	err := json.Unmarshal(parseFormatSet(formatSet), &format)
+	return &format, err
+}
+
+// AddPicture provides the method to add picture in a sheet by given picture
+// format set (such as offset, scale, aspect ratio setting and print settings)
+// and file path. For example:
+//
+//    package main
+//
+//    import (
+//        "fmt"
+//        _ "image/gif"
+//        _ "image/jpeg"
+//        _ "image/png"
+//
+//        "github.com/360EntSecGroup-Skylar/excelize"
+//    )
+//
+//    func main() {
+//        xlsx := excelize.NewFile()
+//        // Insert a picture.
+//        err := xlsx.AddPicture("Sheet1", "A2", "./image1.jpg", "")
+//        if err != nil {
+//            fmt.Println(err)
+//        }
+//        // Insert a picture scaling in the cell with location hyperlink.
+//        err = xlsx.AddPicture("Sheet1", "D2", "./image1.png", `{"x_scale": 0.5, "y_scale": 0.5, "hyperlink": "#Sheet2!D8", "hyperlink_type": "Location"}`)
+//        if err != nil {
+//            fmt.Println(err)
+//        }
+//        // Insert a picture offset in the cell with external hyperlink, printing and positioning support.
+//        err = xlsx.AddPicture("Sheet1", "H2", "./image3.gif", `{"x_offset": 15, "y_offset": 10, "hyperlink": "https://github.com/360EntSecGroup-Skylar/excelize", "hyperlink_type": "External", "print_obj": true, "lock_aspect_ratio": false, "locked": false, "positioning": "oneCell"}`)
+//        if err != nil {
+//            fmt.Println(err)
+//        }
+//        err = xlsx.SaveAs("./Book1.xlsx")
+//        if err != nil {
+//            fmt.Println(err)
+//        }
+//    }
+//
+// LinkType defines two types of hyperlink "External" for web site or
+// "Location" for moving to one of cell in this workbook. When the
+// "hyperlink_type" is "Location", coordinates need to start with "#".
+//
+// Positioning defines two types of the position of a picture in an Excel
+// spreadsheet, "oneCell" (Move but don't size with cells) or "absolute"
+// (Don't move or size with cells). If you don't set this parameter, default
+// positioning is move and size with cells.
+func (f *File) AddPicture(sheet, cell, picture, format string) error {
+	var err error
+	var drawingHyperlinkRID int
+	var hyperlinkType string
+	// Check picture exists first.
+	if _, err = os.Stat(picture); os.IsNotExist(err) {
+		return err
+	}
+	ext, ok := supportImageTypes[path.Ext(picture)]
+	if !ok {
+		return errors.New("Unsupported image extension")
+	}
+	readFile, _ := os.Open(picture)
+	image, _, _ := image.DecodeConfig(readFile)
+	_, file := filepath.Split(picture)
+	formatSet, err := parseFormatPictureSet(format)
+	if err != nil {
+		return err
+	}
+	// Read sheet data.
+	xlsx := f.workSheetReader(sheet)
+	// Add first picture for given sheet, create xl/drawings/ and xl/drawings/_rels/ folder.
+	drawingID := f.countDrawings() + 1
+	pictureID := f.countMedia() + 1
+	drawingXML := "xl/drawings/drawing" + strconv.Itoa(drawingID) + ".xml"
+	drawingID, drawingXML = f.prepareDrawing(xlsx, drawingID, sheet, drawingXML)
+	drawingRID := f.addDrawingRelationships(drawingID, SourceRelationshipImage, "../media/image"+strconv.Itoa(pictureID)+ext, hyperlinkType)
+	// Add picture with hyperlink.
+	if formatSet.Hyperlink != "" && formatSet.HyperlinkType != "" {
+		if formatSet.HyperlinkType == "External" {
+			hyperlinkType = formatSet.HyperlinkType
+		}
+		drawingHyperlinkRID = f.addDrawingRelationships(drawingID, SourceRelationshipHyperLink, formatSet.Hyperlink, hyperlinkType)
+	}
+	f.addDrawingPicture(sheet, drawingXML, cell, file, image.Width, image.Height, drawingRID, drawingHyperlinkRID, formatSet)
+	f.addMedia(picture, ext)
+	f.addContentTypePart(drawingID, "drawings")
+	return err
+}
+
+// addSheetRelationships provides a function to add
+// xl/worksheets/_rels/sheet%d.xml.rels by given worksheet name, relationship
+// type and target.
+func (f *File) addSheetRelationships(sheet, relType, target, targetMode string) int {
+	name, ok := f.sheetMap[trimSheetName(sheet)]
+	if !ok {
+		name = strings.ToLower(sheet) + ".xml"
+	}
+	var rels = "xl/worksheets/_rels/" + strings.TrimPrefix(name, "xl/worksheets/") + ".rels"
+	var sheetRels xlsxWorkbookRels
+	var rID = 1
+	var ID bytes.Buffer
+	ID.WriteString("rId")
+	ID.WriteString(strconv.Itoa(rID))
+	_, ok = f.XLSX[rels]
+	if ok {
+		ID.Reset()
+		_ = xml.Unmarshal([]byte(f.readXML(rels)), &sheetRels)
+		rID = len(sheetRels.Relationships) + 1
+		ID.WriteString("rId")
+		ID.WriteString(strconv.Itoa(rID))
+	}
+	sheetRels.Relationships = append(sheetRels.Relationships, xlsxWorkbookRelation{
+		ID:         ID.String(),
+		Type:       relType,
+		Target:     target,
+		TargetMode: targetMode,
+	})
+	output, _ := xml.Marshal(sheetRels)
+	f.saveFileList(rels, output)
+	return rID
+}
+
+// deleteSheetRelationships provides a function to delete relationships in
+// xl/worksheets/_rels/sheet%d.xml.rels by given worksheet name and
+// relationship index.
+func (f *File) deleteSheetRelationships(sheet, rID string) {
+	name, ok := f.sheetMap[trimSheetName(sheet)]
+	if !ok {
+		name = strings.ToLower(sheet) + ".xml"
+	}
+	var rels = "xl/worksheets/_rels/" + strings.TrimPrefix(name, "xl/worksheets/") + ".rels"
+	var sheetRels xlsxWorkbookRels
+	_ = xml.Unmarshal([]byte(f.readXML(rels)), &sheetRels)
+	for k, v := range sheetRels.Relationships {
+		if v.ID == rID {
+			sheetRels.Relationships = append(sheetRels.Relationships[:k], sheetRels.Relationships[k+1:]...)
+		}
+	}
+	output, _ := xml.Marshal(sheetRels)
+	f.saveFileList(rels, output)
+}
+
+// addSheetLegacyDrawing provides a function to add legacy drawing element to
+// xl/worksheets/sheet%d.xml by given worksheet name and relationship index.
+func (f *File) addSheetLegacyDrawing(sheet string, rID int) {
+	xlsx := f.workSheetReader(sheet)
+	xlsx.LegacyDrawing = &xlsxLegacyDrawing{
+		RID: "rId" + strconv.Itoa(rID),
+	}
+}
+
+// addSheetDrawing provides a function to add drawing element to
+// xl/worksheets/sheet%d.xml by given worksheet name and relationship index.
+func (f *File) addSheetDrawing(sheet string, rID int) {
+	xlsx := f.workSheetReader(sheet)
+	xlsx.Drawing = &xlsxDrawing{
+		RID: "rId" + strconv.Itoa(rID),
+	}
+}
+
+// addSheetPicture provides a function to add picture element to
+// xl/worksheets/sheet%d.xml by given worksheet name and relationship index.
+func (f *File) addSheetPicture(sheet string, rID int) {
+	xlsx := f.workSheetReader(sheet)
+	xlsx.Picture = &xlsxPicture{
+		RID: "rId" + strconv.Itoa(rID),
+	}
+}
+
+// countDrawings provides a function to get drawing files count storage in the
+// folder xl/drawings.
+func (f *File) countDrawings() int {
+	count := 0
+	for k := range f.XLSX {
+		if strings.Contains(k, "xl/drawings/drawing") {
+			count++
+		}
+	}
+	return count
+}
+
+// addDrawingPicture provides a function to add picture by given sheet,
+// drawingXML, cell, file name, width, height relationship index and format
+// sets.
+func (f *File) addDrawingPicture(sheet, drawingXML, cell, file string, width, height, rID, hyperlinkRID int, formatSet *formatPicture) {
+	cell = strings.ToUpper(cell)
+	fromCol := string(strings.Map(letterOnlyMapF, cell))
+	fromRow, _ := strconv.Atoi(strings.Map(intOnlyMapF, cell))
+	row := fromRow - 1
+	col := TitleToNumber(fromCol)
+	width = int(float64(width) * formatSet.XScale)
+	height = int(float64(height) * formatSet.YScale)
+	colStart, rowStart, _, _, colEnd, rowEnd, x2, y2 := f.positionObjectPixels(sheet, col, row, formatSet.OffsetX, formatSet.OffsetY, width, height)
+	content := xlsxWsDr{}
+	content.A = NameSpaceDrawingML
+	content.Xdr = NameSpaceDrawingMLSpreadSheet
+	cNvPrID := f.drawingParser(drawingXML, &content)
+	twoCellAnchor := xdrCellAnchor{}
+	twoCellAnchor.EditAs = formatSet.Positioning
+	from := xlsxFrom{}
+	from.Col = colStart
+	from.ColOff = formatSet.OffsetX * EMU
+	from.Row = rowStart
+	from.RowOff = formatSet.OffsetY * EMU
+	to := xlsxTo{}
+	to.Col = colEnd
+	to.ColOff = x2 * EMU
+	to.Row = rowEnd
+	to.RowOff = y2 * EMU
+	twoCellAnchor.From = &from
+	twoCellAnchor.To = &to
+	pic := xlsxPic{}
+	pic.NvPicPr.CNvPicPr.PicLocks.NoChangeAspect = formatSet.NoChangeAspect
+	pic.NvPicPr.CNvPr.ID = f.countCharts() + f.countMedia() + 1
+	pic.NvPicPr.CNvPr.Descr = file
+	pic.NvPicPr.CNvPr.Name = "Picture " + strconv.Itoa(cNvPrID)
+	if hyperlinkRID != 0 {
+		pic.NvPicPr.CNvPr.HlinkClick = &xlsxHlinkClick{
+			R:   SourceRelationship,
+			RID: "rId" + strconv.Itoa(hyperlinkRID),
+		}
+	}
+	pic.BlipFill.Blip.R = SourceRelationship
+	pic.BlipFill.Blip.Embed = "rId" + strconv.Itoa(rID)
+	pic.SpPr.PrstGeom.Prst = "rect"
+
+	twoCellAnchor.Pic = &pic
+	twoCellAnchor.ClientData = &xdrClientData{
+		FLocksWithSheet:  formatSet.FLocksWithSheet,
+		FPrintsWithSheet: formatSet.FPrintsWithSheet,
+	}
+	content.TwoCellAnchor = append(content.TwoCellAnchor, &twoCellAnchor)
+	output, _ := xml.Marshal(content)
+	f.saveFileList(drawingXML, output)
+}
+
+// addDrawingRelationships provides a function to add image part relationships
+// in the file xl/drawings/_rels/drawing%d.xml.rels by given drawing index,
+// relationship type and target.
+func (f *File) addDrawingRelationships(index int, relType, target, targetMode string) int {
+	var rels = "xl/drawings/_rels/drawing" + strconv.Itoa(index) + ".xml.rels"
+	var drawingRels xlsxWorkbookRels
+	var rID = 1
+	var ID bytes.Buffer
+	ID.WriteString("rId")
+	ID.WriteString(strconv.Itoa(rID))
+	_, ok := f.XLSX[rels]
+	if ok {
+		ID.Reset()
+		_ = xml.Unmarshal([]byte(f.readXML(rels)), &drawingRels)
+		rID = len(drawingRels.Relationships) + 1
+		ID.WriteString("rId")
+		ID.WriteString(strconv.Itoa(rID))
+	}
+	drawingRels.Relationships = append(drawingRels.Relationships, xlsxWorkbookRelation{
+		ID:         ID.String(),
+		Type:       relType,
+		Target:     target,
+		TargetMode: targetMode,
+	})
+	output, _ := xml.Marshal(drawingRels)
+	f.saveFileList(rels, output)
+	return rID
+}
+
+// countMedia provides a function to get media files count storage in the
+// folder xl/media/image.
+func (f *File) countMedia() int {
+	count := 0
+	for k := range f.XLSX {
+		if strings.Contains(k, "xl/media/image") {
+			count++
+		}
+	}
+	return count
+}
+
+// addMedia provides a function to add picture into folder xl/media/image by
+// given file name and extension name.
+func (f *File) addMedia(file, ext string) {
+	count := f.countMedia()
+	dat, _ := ioutil.ReadFile(file)
+	media := "xl/media/image" + strconv.Itoa(count+1) + ext
+	f.XLSX[media] = dat
+}
+
+// setContentTypePartImageExtensions provides a function to set the content
+// type for relationship parts and the Main Document part.
+func (f *File) setContentTypePartImageExtensions() {
+	var imageTypes = map[string]bool{"jpeg": false, "png": false, "gif": false}
+	content := f.contentTypesReader()
+	for _, v := range content.Defaults {
+		_, ok := imageTypes[v.Extension]
+		if ok {
+			imageTypes[v.Extension] = true
+		}
+	}
+	for k, v := range imageTypes {
+		if !v {
+			content.Defaults = append(content.Defaults, xlsxDefault{
+				Extension:   k,
+				ContentType: "image/" + k,
+			})
+		}
+	}
+}
+
+// setContentTypePartVMLExtensions provides a function to set the content type
+// for relationship parts and the Main Document part.
+func (f *File) setContentTypePartVMLExtensions() {
+	vml := false
+	content := f.contentTypesReader()
+	for _, v := range content.Defaults {
+		if v.Extension == "vml" {
+			vml = true
+		}
+	}
+	if !vml {
+		content.Defaults = append(content.Defaults, xlsxDefault{
+			Extension:   "vml",
+			ContentType: "application/vnd.openxmlformats-officedocument.vmlDrawing",
+		})
+	}
+}
+
+// addContentTypePart provides a function to add content type part
+// relationships in the file [Content_Types].xml by given index.
+func (f *File) addContentTypePart(index int, contentType string) {
+	setContentType := map[string]func(){
+		"comments": f.setContentTypePartVMLExtensions,
+		"drawings": f.setContentTypePartImageExtensions,
+	}
+	partNames := map[string]string{
+		"chart":    "/xl/charts/chart" + strconv.Itoa(index) + ".xml",
+		"comments": "/xl/comments" + strconv.Itoa(index) + ".xml",
+		"drawings": "/xl/drawings/drawing" + strconv.Itoa(index) + ".xml",
+		"table":    "/xl/tables/table" + strconv.Itoa(index) + ".xml",
+	}
+	contentTypes := map[string]string{
+		"chart":    "application/vnd.openxmlformats-officedocument.drawingml.chart+xml",
+		"comments": "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml",
+		"drawings": "application/vnd.openxmlformats-officedocument.drawing+xml",
+		"table":    "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml",
+	}
+	s, ok := setContentType[contentType]
+	if ok {
+		s()
+	}
+	content := f.contentTypesReader()
+	for _, v := range content.Overrides {
+		if v.PartName == partNames[contentType] {
+			return
+		}
+	}
+	content.Overrides = append(content.Overrides, xlsxOverride{
+		PartName:    partNames[contentType],
+		ContentType: contentTypes[contentType],
+	})
+}
+
+// getSheetRelationshipsTargetByID provides a function to get Target attribute
+// value in xl/worksheets/_rels/sheet%d.xml.rels by given worksheet name and
+// relationship index.
+func (f *File) getSheetRelationshipsTargetByID(sheet, rID string) string {
+	name, ok := f.sheetMap[trimSheetName(sheet)]
+	if !ok {
+		name = strings.ToLower(sheet) + ".xml"
+	}
+	var rels = "xl/worksheets/_rels/" + strings.TrimPrefix(name, "xl/worksheets/") + ".rels"
+	var sheetRels xlsxWorkbookRels
+	_ = xml.Unmarshal([]byte(f.readXML(rels)), &sheetRels)
+	for _, v := range sheetRels.Relationships {
+		if v.ID == rID {
+			return v.Target
+		}
+	}
+	return ""
+}
+
+// GetPicture provides a function to get picture base name and raw content
+// embed in XLSX by given worksheet and cell name. This function returns the
+// file name in XLSX and file contents as []byte data types. For example:
+//
+//    xlsx, err := excelize.OpenFile("./Book1.xlsx")
+//    if err != nil {
+//        fmt.Println(err)
+//        return
+//    }
+//    file, raw := xlsx.GetPicture("Sheet1", "A2")
+//    if file == "" {
+//        return
+//    }
+//    err := ioutil.WriteFile(file, raw, 0644)
+//    if err != nil {
+//        fmt.Println(err)
+//    }
+//
+func (f *File) GetPicture(sheet, cell string) (string, []byte) {
+	xlsx := f.workSheetReader(sheet)
+	if xlsx.Drawing == nil {
+		return "", []byte{}
+	}
+	target := f.getSheetRelationshipsTargetByID(sheet, xlsx.Drawing.RID)
+	drawingXML := strings.Replace(target, "..", "xl", -1)
+
+	_, ok := f.XLSX[drawingXML]
+	if !ok {
+		return "", nil
+	}
+	decodeWsDr := decodeWsDr{}
+	_ = xml.Unmarshal([]byte(f.readXML(drawingXML)), &decodeWsDr)
+
+	cell = strings.ToUpper(cell)
+	fromCol := string(strings.Map(letterOnlyMapF, cell))
+	fromRow, _ := strconv.Atoi(strings.Map(intOnlyMapF, cell))
+	row := fromRow - 1
+	col := TitleToNumber(fromCol)
+
+	drawingRelationships := strings.Replace(strings.Replace(target, "../drawings", "xl/drawings/_rels", -1), ".xml", ".xml.rels", -1)
+
+	for _, anchor := range decodeWsDr.TwoCellAnchor {
+		decodeTwoCellAnchor := decodeTwoCellAnchor{}
+		_ = xml.Unmarshal([]byte("<decodeTwoCellAnchor>"+anchor.Content+"</decodeTwoCellAnchor>"), &decodeTwoCellAnchor)
+		if decodeTwoCellAnchor.From != nil && decodeTwoCellAnchor.Pic != nil {
+			if decodeTwoCellAnchor.From.Col == col && decodeTwoCellAnchor.From.Row == row {
+				xlsxWorkbookRelation := f.getDrawingRelationships(drawingRelationships, decodeTwoCellAnchor.Pic.BlipFill.Blip.Embed)
+				_, ok := supportImageTypes[filepath.Ext(xlsxWorkbookRelation.Target)]
+				if ok {
+					return filepath.Base(xlsxWorkbookRelation.Target), []byte(f.XLSX[strings.Replace(xlsxWorkbookRelation.Target, "..", "xl", -1)])
+				}
+			}
+		}
+	}
+	return "", []byte{}
+}
+
+// getDrawingRelationships provides a function to get drawing relationships
+// from xl/drawings/_rels/drawing%s.xml.rels by given file name and
+// relationship ID.
+func (f *File) getDrawingRelationships(rels, rID string) *xlsxWorkbookRelation {
+	_, ok := f.XLSX[rels]
+	if !ok {
+		return nil
+	}
+	var drawingRels xlsxWorkbookRels
+	_ = xml.Unmarshal([]byte(f.readXML(rels)), &drawingRels)
+	for _, v := range drawingRels.Relationships {
+		if v.ID == rID {
+			return &v
+		}
+	}
+	return nil
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/rows.go

@@ -0,0 +1,462 @@
+package excelize
+
+import (
+	"bytes"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"math"
+	"strconv"
+	"strings"
+)
+
+// GetRows return all the rows in a sheet by given worksheet name (case
+// sensitive). For example:
+//
+//    for _, row := range xlsx.GetRows("Sheet1") {
+//        for _, colCell := range row {
+//            fmt.Print(colCell, "\t")
+//        }
+//        fmt.Println()
+//    }
+//
+func (f *File) GetRows(sheet string) [][]string {
+	xlsx := f.workSheetReader(sheet)
+	rows := [][]string{}
+	name, ok := f.sheetMap[trimSheetName(sheet)]
+	if !ok {
+		return rows
+	}
+	if xlsx != nil {
+		output, _ := xml.Marshal(f.Sheet[name])
+		f.saveFileList(name, replaceWorkSheetsRelationshipsNameSpaceBytes(output))
+	}
+	xml.NewDecoder(bytes.NewReader(f.readXML(name)))
+	d := f.sharedStringsReader()
+	var inElement string
+	var r xlsxRow
+	var row []string
+	tr, tc := f.getTotalRowsCols(name)
+	for i := 0; i < tr; i++ {
+		row = []string{}
+		for j := 0; j <= tc; j++ {
+			row = append(row, "")
+		}
+		rows = append(rows, row)
+	}
+	decoder := xml.NewDecoder(bytes.NewReader(f.readXML(name)))
+	for {
+		token, _ := decoder.Token()
+		if token == nil {
+			break
+		}
+		switch startElement := token.(type) {
+		case xml.StartElement:
+			inElement = startElement.Name.Local
+			if inElement == "row" {
+				r = xlsxRow{}
+				_ = decoder.DecodeElement(&r, &startElement)
+				cr := r.R - 1
+				for _, colCell := range r.C {
+					c := TitleToNumber(strings.Map(letterOnlyMapF, colCell.R))
+					val, _ := colCell.getValueFrom(f, d)
+					rows[cr][c] = val
+				}
+			}
+		default:
+		}
+	}
+	return rows
+}
+
+// Rows defines an iterator to a sheet
+type Rows struct {
+	decoder *xml.Decoder
+	token   xml.Token
+	err     error
+	f       *File
+}
+
+// Next will return true if find the next row element.
+func (rows *Rows) Next() bool {
+	for {
+		rows.token, rows.err = rows.decoder.Token()
+		if rows.err == io.EOF {
+			rows.err = nil
+		}
+		if rows.token == nil {
+			return false
+		}
+
+		switch startElement := rows.token.(type) {
+		case xml.StartElement:
+			inElement := startElement.Name.Local
+			if inElement == "row" {
+				return true
+			}
+		}
+	}
+}
+
+// Error will return the error when the find next row element
+func (rows *Rows) Error() error {
+	return rows.err
+}
+
+// Columns return the current row's column values
+func (rows *Rows) Columns() []string {
+	if rows.token == nil {
+		return []string{}
+	}
+	startElement := rows.token.(xml.StartElement)
+	r := xlsxRow{}
+	_ = rows.decoder.DecodeElement(&r, &startElement)
+	d := rows.f.sharedStringsReader()
+	row := make([]string, len(r.C))
+	for _, colCell := range r.C {
+		c := TitleToNumber(strings.Map(letterOnlyMapF, colCell.R))
+		val, _ := colCell.getValueFrom(rows.f, d)
+		row[c] = val
+	}
+	return row
+}
+
+// ErrSheetNotExist defines an error of sheet is not exist
+type ErrSheetNotExist struct {
+	SheetName string
+}
+
+func (err ErrSheetNotExist) Error() string {
+	return fmt.Sprintf("Sheet %s is not exist", string(err.SheetName))
+}
+
+// Rows return a rows iterator. For example:
+//
+//    rows, err := xlsx.Rows("Sheet1")
+//    for rows.Next() {
+//        for _, colCell := range rows.Columns() {
+//            fmt.Print(colCell, "\t")
+//        }
+//        fmt.Println()
+//    }
+//
+func (f *File) Rows(sheet string) (*Rows, error) {
+	xlsx := f.workSheetReader(sheet)
+	name, ok := f.sheetMap[trimSheetName(sheet)]
+	if !ok {
+		return nil, ErrSheetNotExist{sheet}
+	}
+	if xlsx != nil {
+		output, _ := xml.Marshal(f.Sheet[name])
+		f.saveFileList(name, replaceWorkSheetsRelationshipsNameSpaceBytes(output))
+	}
+	return &Rows{
+		f:       f,
+		decoder: xml.NewDecoder(bytes.NewReader(f.readXML(name))),
+	}, nil
+}
+
+// getTotalRowsCols provides a function to get total columns and rows in a
+// worksheet.
+func (f *File) getTotalRowsCols(name string) (int, int) {
+	decoder := xml.NewDecoder(bytes.NewReader(f.readXML(name)))
+	var inElement string
+	var r xlsxRow
+	var tr, tc int
+	for {
+		token, _ := decoder.Token()
+		if token == nil {
+			break
+		}
+		switch startElement := token.(type) {
+		case xml.StartElement:
+			inElement = startElement.Name.Local
+			if inElement == "row" {
+				r = xlsxRow{}
+				_ = decoder.DecodeElement(&r, &startElement)
+				tr = r.R
+				for _, colCell := range r.C {
+					col := TitleToNumber(strings.Map(letterOnlyMapF, colCell.R))
+					if col > tc {
+						tc = col
+					}
+				}
+			}
+		default:
+		}
+	}
+	return tr, tc
+}
+
+// SetRowHeight provides a function to set the height of a single row. For
+// example, set the height of the first row in Sheet1:
+//
+//    xlsx.SetRowHeight("Sheet1", 1, 50)
+//
+func (f *File) SetRowHeight(sheet string, row int, height float64) {
+	xlsx := f.workSheetReader(sheet)
+	cells := 0
+	rowIdx := row - 1
+	completeRow(xlsx, row, cells)
+	xlsx.SheetData.Row[rowIdx].Ht = height
+	xlsx.SheetData.Row[rowIdx].CustomHeight = true
+}
+
+// getRowHeight provides a function to get row height in pixels by given sheet
+// name and row index.
+func (f *File) getRowHeight(sheet string, row int) int {
+	xlsx := f.workSheetReader(sheet)
+	for _, v := range xlsx.SheetData.Row {
+		if v.R == row+1 && v.Ht != 0 {
+			return int(convertRowHeightToPixels(v.Ht))
+		}
+	}
+	// Optimisation for when the row heights haven't changed.
+	return int(defaultRowHeightPixels)
+}
+
+// GetRowHeight provides a function to get row height by given worksheet name
+// and row index. For example, get the height of the first row in Sheet1:
+//
+//    xlsx.GetRowHeight("Sheet1", 1)
+//
+func (f *File) GetRowHeight(sheet string, row int) float64 {
+	xlsx := f.workSheetReader(sheet)
+	for _, v := range xlsx.SheetData.Row {
+		if v.R == row && v.Ht != 0 {
+			return v.Ht
+		}
+	}
+	// Optimisation for when the row heights haven't changed.
+	return defaultRowHeightPixels
+}
+
+// sharedStringsReader provides a function to get the pointer to the structure
+// after deserialization of xl/sharedStrings.xml.
+func (f *File) sharedStringsReader() *xlsxSST {
+	if f.SharedStrings == nil {
+		var sharedStrings xlsxSST
+		ss := f.readXML("xl/sharedStrings.xml")
+		if len(ss) == 0 {
+			ss = f.readXML("xl/SharedStrings.xml")
+		}
+		_ = xml.Unmarshal([]byte(ss), &sharedStrings)
+		f.SharedStrings = &sharedStrings
+	}
+	return f.SharedStrings
+}
+
+// getValueFrom return a value from a column/row cell, this function is
+// inteded to be used with for range on rows an argument with the xlsx opened
+// file.
+func (xlsx *xlsxC) getValueFrom(f *File, d *xlsxSST) (string, error) {
+	switch xlsx.T {
+	case "s":
+		xlsxSI := 0
+		xlsxSI, _ = strconv.Atoi(xlsx.V)
+		if len(d.SI[xlsxSI].R) > 0 {
+			value := ""
+			for _, v := range d.SI[xlsxSI].R {
+				value += v.T
+			}
+			return value, nil
+		}
+		return f.formattedValue(xlsx.S, d.SI[xlsxSI].T), nil
+	case "str":
+		return f.formattedValue(xlsx.S, xlsx.V), nil
+	case "inlineStr":
+		return f.formattedValue(xlsx.S, xlsx.IS.T), nil
+	default:
+		return f.formattedValue(xlsx.S, xlsx.V), nil
+	}
+}
+
+// SetRowVisible provides a function to set visible of a single row by given
+// worksheet name and row index. For example, hide row 2 in Sheet1:
+//
+//    xlsx.SetRowVisible("Sheet1", 2, false)
+//
+func (f *File) SetRowVisible(sheet string, rowIndex int, visible bool) {
+	xlsx := f.workSheetReader(sheet)
+	rows := rowIndex + 1
+	cells := 0
+	completeRow(xlsx, rows, cells)
+	if visible {
+		xlsx.SheetData.Row[rowIndex].Hidden = false
+		return
+	}
+	xlsx.SheetData.Row[rowIndex].Hidden = true
+}
+
+// GetRowVisible provides a function to get visible of a single row by given
+// worksheet name and row index. For example, get visible state of row 2 in
+// Sheet1:
+//
+//    xlsx.GetRowVisible("Sheet1", 2)
+//
+func (f *File) GetRowVisible(sheet string, rowIndex int) bool {
+	xlsx := f.workSheetReader(sheet)
+	rows := rowIndex + 1
+	cells := 0
+	completeRow(xlsx, rows, cells)
+	return !xlsx.SheetData.Row[rowIndex].Hidden
+}
+
+// SetRowOutlineLevel provides a function to set outline level number of a
+// single row by given worksheet name and row index. For example, outline row
+// 2 in Sheet1 to level 1:
+//
+//    xlsx.SetRowOutlineLevel("Sheet1", 2, 1)
+//
+func (f *File) SetRowOutlineLevel(sheet string, rowIndex int, level uint8) {
+	xlsx := f.workSheetReader(sheet)
+	rows := rowIndex + 1
+	cells := 0
+	completeRow(xlsx, rows, cells)
+	xlsx.SheetData.Row[rowIndex].OutlineLevel = level
+}
+
+// GetRowOutlineLevel provides a function to get outline level number of a
+// single row by given worksheet name and row index. For example, get outline
+// number of row 2 in Sheet1:
+//
+//    xlsx.GetRowOutlineLevel("Sheet1", 2)
+//
+func (f *File) GetRowOutlineLevel(sheet string, rowIndex int) uint8 {
+	xlsx := f.workSheetReader(sheet)
+	rows := rowIndex + 1
+	cells := 0
+	completeRow(xlsx, rows, cells)
+	return xlsx.SheetData.Row[rowIndex].OutlineLevel
+}
+
+// RemoveRow provides a function to remove single row by given worksheet name
+// and row index. For example, remove row 3 in Sheet1:
+//
+//    xlsx.RemoveRow("Sheet1", 2)
+//
+func (f *File) RemoveRow(sheet string, row int) {
+	if row < 0 {
+		return
+	}
+	xlsx := f.workSheetReader(sheet)
+	row++
+	for i, r := range xlsx.SheetData.Row {
+		if r.R == row {
+			xlsx.SheetData.Row = append(xlsx.SheetData.Row[:i], xlsx.SheetData.Row[i+1:]...)
+			f.adjustHelper(sheet, -1, row, -1)
+			return
+		}
+	}
+}
+
+// InsertRow provides a function to insert a new row before given row index.
+// For example, create a new row before row 3 in Sheet1:
+//
+//    xlsx.InsertRow("Sheet1", 2)
+//
+func (f *File) InsertRow(sheet string, row int) {
+	if row < 0 {
+		return
+	}
+	row++
+	f.adjustHelper(sheet, -1, row, 1)
+}
+
+// checkRow provides a function to check and fill each column element for all
+// rows and make that is continuous in a worksheet of XML. For example:
+//
+//    <row r="15" spans="1:22" x14ac:dyDescent="0.2">
+//        <c r="A15" s="2" />
+//        <c r="B15" s="2" />
+//        <c r="F15" s="1" />
+//        <c r="G15" s="1" />
+//    </row>
+//
+// in this case, we should to change it to
+//
+//    <row r="15" spans="1:22" x14ac:dyDescent="0.2">
+//        <c r="A15" s="2" />
+//        <c r="B15" s="2" />
+//        <c r="C15" s="2" />
+//        <c r="D15" s="2" />
+//        <c r="E15" s="2" />
+//        <c r="F15" s="1" />
+//        <c r="G15" s="1" />
+//    </row>
+//
+// Noteice: this method could be very slow for large spreadsheets (more than
+// 3000 rows one sheet).
+func checkRow(xlsx *xlsxWorksheet) {
+	buffer := bytes.Buffer{}
+	for k := range xlsx.SheetData.Row {
+		lenCol := len(xlsx.SheetData.Row[k].C)
+		if lenCol > 0 {
+			endR := string(strings.Map(letterOnlyMapF, xlsx.SheetData.Row[k].C[lenCol-1].R))
+			endRow, _ := strconv.Atoi(strings.Map(intOnlyMapF, xlsx.SheetData.Row[k].C[lenCol-1].R))
+			endCol := TitleToNumber(endR) + 1
+			if lenCol < endCol {
+				oldRow := xlsx.SheetData.Row[k].C
+				xlsx.SheetData.Row[k].C = xlsx.SheetData.Row[k].C[:0]
+				tmp := []xlsxC{}
+				for i := 0; i < endCol; i++ {
+					buffer.WriteString(ToAlphaString(i))
+					buffer.WriteString(strconv.Itoa(endRow))
+					tmp = append(tmp, xlsxC{
+						R: buffer.String(),
+					})
+					buffer.Reset()
+				}
+				xlsx.SheetData.Row[k].C = tmp
+				for _, y := range oldRow {
+					colAxis := TitleToNumber(string(strings.Map(letterOnlyMapF, y.R)))
+					xlsx.SheetData.Row[k].C[colAxis] = y
+				}
+			}
+		}
+	}
+}
+
+// completeRow provides a function to check and fill each column element for a
+// single row and make that is continuous in a worksheet of XML by given row
+// index and axis.
+func completeRow(xlsx *xlsxWorksheet, row, cell int) {
+	currentRows := len(xlsx.SheetData.Row)
+	if currentRows > 1 {
+		lastRow := xlsx.SheetData.Row[currentRows-1].R
+		if lastRow >= row {
+			row = lastRow
+		}
+	}
+	for i := currentRows; i < row; i++ {
+		xlsx.SheetData.Row = append(xlsx.SheetData.Row, xlsxRow{
+			R: i + 1,
+		})
+	}
+	buffer := bytes.Buffer{}
+	for ii := currentRows; ii < row; ii++ {
+		start := len(xlsx.SheetData.Row[ii].C)
+		if start == 0 {
+			for iii := start; iii < cell; iii++ {
+				buffer.WriteString(ToAlphaString(iii))
+				buffer.WriteString(strconv.Itoa(ii + 1))
+				xlsx.SheetData.Row[ii].C = append(xlsx.SheetData.Row[ii].C, xlsxC{
+					R: buffer.String(),
+				})
+				buffer.Reset()
+			}
+		}
+	}
+}
+
+// convertRowHeightToPixels provides a function to convert the height of a
+// cell from user's units to pixels. If the height hasn't been set by the user
+// we use the default value. If the row is hidden it has a value of zero.
+func convertRowHeightToPixels(height float64) float64 {
+	var pixels float64
+	if height == 0 {
+		return pixels
+	}
+	pixels = math.Ceil(4.0 / 3.0 * height)
+	return pixels
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/shape.go

@@ -0,0 +1,419 @@
+package excelize
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"strconv"
+	"strings"
+)
+
+// parseFormatShapeSet provides a function to parse the format settings of the
+// shape with default value.
+func parseFormatShapeSet(formatSet string) (*formatShape, error) {
+	format := formatShape{
+		Width:  160,
+		Height: 160,
+		Format: formatPicture{
+			FPrintsWithSheet: true,
+			FLocksWithSheet:  false,
+			NoChangeAspect:   false,
+			OffsetX:          0,
+			OffsetY:          0,
+			XScale:           1.0,
+			YScale:           1.0,
+		},
+	}
+	err := json.Unmarshal([]byte(formatSet), &format)
+	return &format, err
+}
+
+// AddShape provides the method to add shape in a sheet by given worksheet
+// index, shape format set (such as offset, scale, aspect ratio setting and
+// print settings) and properties set. For example, add text box (rect shape)
+// in Sheet1:
+//
+//    xlsx.AddShape("Sheet1", "G6", `{"type":"rect","color":{"line":"#4286F4","fill":"#8eb9ff"},"paragraph":[{"text":"Rectangle Shape","font":{"bold":true,"italic":true,"family":"Berlin Sans FB Demi","size":36,"color":"#777777","underline":"sng"}}],"width":180,"height": 90}`)
+//
+// The following shows the type of shape supported by excelize:
+//
+//    accentBorderCallout1 (Callout 1 with Border and Accent Shape)
+//    accentBorderCallout2 (Callout 2 with Border and Accent Shape)
+//    accentBorderCallout3 (Callout 3 with Border and Accent Shape)
+//    accentCallout1 (Callout 1 Shape)
+//    accentCallout2 (Callout 2 Shape)
+//    accentCallout3 (Callout 3 Shape)
+//    actionButtonBackPrevious (Back or Previous Button Shape)
+//    actionButtonBeginning (Beginning Button Shape)
+//    actionButtonBlank (Blank Button Shape)
+//    actionButtonDocument (Document Button Shape)
+//    actionButtonEnd (End Button Shape)
+//    actionButtonForwardNext (Forward or Next Button Shape)
+//    actionButtonHelp (Help Button Shape)
+//    actionButtonHome (Home Button Shape)
+//    actionButtonInformation (Information Button Shape)
+//    actionButtonMovie (Movie Button Shape)
+//    actionButtonReturn (Return Button Shape)
+//    actionButtonSound (Sound Button Shape)
+//    arc (Curved Arc Shape)
+//    bentArrow (Bent Arrow Shape)
+//    bentConnector2 (Bent Connector 2 Shape)
+//    bentConnector3 (Bent Connector 3 Shape)
+//    bentConnector4 (Bent Connector 4 Shape)
+//    bentConnector5 (Bent Connector 5 Shape)
+//    bentUpArrow (Bent Up Arrow Shape)
+//    bevel (Bevel Shape)
+//    blockArc (Block Arc Shape)
+//    borderCallout1 (Callout 1 with Border Shape)
+//    borderCallout2 (Callout 2 with Border Shape)
+//    borderCallout3 (Callout 3 with Border Shape)
+//    bracePair (Brace Pair Shape)
+//    bracketPair (Bracket Pair Shape)
+//    callout1 (Callout 1 Shape)
+//    callout2 (Callout 2 Shape)
+//    callout3 (Callout 3 Shape)
+//    can (Can Shape)
+//    chartPlus (Chart Plus Shape)
+//    chartStar (Chart Star Shape)
+//    chartX (Chart X Shape)
+//    chevron (Chevron Shape)
+//    chord (Chord Shape)
+//    circularArrow (Circular Arrow Shape)
+//    cloud (Cloud Shape)
+//    cloudCallout (Callout Cloud Shape)
+//    corner (Corner Shape)
+//    cornerTabs (Corner Tabs Shape)
+//    cube (Cube Shape)
+//    curvedConnector2 (Curved Connector 2 Shape)
+//    curvedConnector3 (Curved Connector 3 Shape)
+//    curvedConnector4 (Curved Connector 4 Shape)
+//    curvedConnector5 (Curved Connector 5 Shape)
+//    curvedDownArrow (Curved Down Arrow Shape)
+//    curvedLeftArrow (Curved Left Arrow Shape)
+//    curvedRightArrow (Curved Right Arrow Shape)
+//    curvedUpArrow (Curved Up Arrow Shape)
+//    decagon (Decagon Shape)
+//    diagStripe (Diagonal Stripe Shape)
+//    diamond (Diamond Shape)
+//    dodecagon (Dodecagon Shape)
+//    donut (Donut Shape)
+//    doubleWave (Double Wave Shape)
+//    downArrow (Down Arrow Shape)
+//    downArrowCallout (Callout Down Arrow Shape)
+//    ellipse (Ellipse Shape)
+//    ellipseRibbon (Ellipse Ribbon Shape)
+//    ellipseRibbon2 (Ellipse Ribbon 2 Shape)
+//    flowChartAlternateProcess (Alternate Process Flow Shape)
+//    flowChartCollate (Collate Flow Shape)
+//    flowChartConnector (Connector Flow Shape)
+//    flowChartDecision (Decision Flow Shape)
+//    flowChartDelay (Delay Flow Shape)
+//    flowChartDisplay (Display Flow Shape)
+//    flowChartDocument (Document Flow Shape)
+//    flowChartExtract (Extract Flow Shape)
+//    flowChartInputOutput (Input Output Flow Shape)
+//    flowChartInternalStorage (Internal Storage Flow Shape)
+//    flowChartMagneticDisk (Magnetic Disk Flow Shape)
+//    flowChartMagneticDrum (Magnetic Drum Flow Shape)
+//    flowChartMagneticTape (Magnetic Tape Flow Shape)
+//    flowChartManualInput (Manual Input Flow Shape)
+//    flowChartManualOperation (Manual Operation Flow Shape)
+//    flowChartMerge (Merge Flow Shape)
+//    flowChartMultidocument (Multi-Document Flow Shape)
+//    flowChartOfflineStorage (Offline Storage Flow Shape)
+//    flowChartOffpageConnector (Off-Page Connector Flow Shape)
+//    flowChartOnlineStorage (Online Storage Flow Shape)
+//    flowChartOr (Or Flow Shape)
+//    flowChartPredefinedProcess (Predefined Process Flow Shape)
+//    flowChartPreparation (Preparation Flow Shape)
+//    flowChartProcess (Process Flow Shape)
+//    flowChartPunchedCard (Punched Card Flow Shape)
+//    flowChartPunchedTape (Punched Tape Flow Shape)
+//    flowChartSort (Sort Flow Shape)
+//    flowChartSummingJunction (Summing Junction Flow Shape)
+//    flowChartTerminator (Terminator Flow Shape)
+//    foldedCorner (Folded Corner Shape)
+//    frame (Frame Shape)
+//    funnel (Funnel Shape)
+//    gear6 (Gear 6 Shape)
+//    gear9 (Gear 9 Shape)
+//    halfFrame (Half Frame Shape)
+//    heart (Heart Shape)
+//    heptagon (Heptagon Shape)
+//    hexagon (Hexagon Shape)
+//    homePlate (Home Plate Shape)
+//    horizontalScroll (Horizontal Scroll Shape)
+//    irregularSeal1 (Irregular Seal 1 Shape)
+//    irregularSeal2 (Irregular Seal 2 Shape)
+//    leftArrow (Left Arrow Shape)
+//    leftArrowCallout (Callout Left Arrow Shape)
+//    leftBrace (Left Brace Shape)
+//    leftBracket (Left Bracket Shape)
+//    leftCircularArrow (Left Circular Arrow Shape)
+//    leftRightArrow (Left Right Arrow Shape)
+//    leftRightArrowCallout (Callout Left Right Arrow Shape)
+//    leftRightCircularArrow (Left Right Circular Arrow Shape)
+//    leftRightRibbon (Left Right Ribbon Shape)
+//    leftRightUpArrow (Left Right Up Arrow Shape)
+//    leftUpArrow (Left Up Arrow Shape)
+//    lightningBolt (Lightning Bolt Shape)
+//    line (Line Shape)
+//    lineInv (Line Inverse Shape)
+//    mathDivide (Divide Math Shape)
+//    mathEqual (Equal Math Shape)
+//    mathMinus (Minus Math Shape)
+//    mathMultiply (Multiply Math Shape)
+//    mathNotEqual (Not Equal Math Shape)
+//    mathPlus (Plus Math Shape)
+//    moon (Moon Shape)
+//    nonIsoscelesTrapezoid (Non-Isosceles Trapezoid Shape)
+//    noSmoking (No Smoking Shape)
+//    notchedRightArrow (Notched Right Arrow Shape)
+//    octagon (Octagon Shape)
+//    parallelogram (Parallelogram Shape)
+//    pentagon (Pentagon Shape)
+//    pie (Pie Shape)
+//    pieWedge (Pie Wedge Shape)
+//    plaque (Plaque Shape)
+//    plaqueTabs (Plaque Tabs Shape)
+//    plus (Plus Shape)
+//    quadArrow (Quad-Arrow Shape)
+//    quadArrowCallout (Callout Quad-Arrow Shape)
+//    rect (Rectangle Shape)
+//    ribbon (Ribbon Shape)
+//    ribbon2 (Ribbon 2 Shape)
+//    rightArrow (Right Arrow Shape)
+//    rightArrowCallout (Callout Right Arrow Shape)
+//    rightBrace (Right Brace Shape)
+//    rightBracket (Right Bracket Shape)
+//    round1Rect (One Round Corner Rectangle Shape)
+//    round2DiagRect (Two Diagonal Round Corner Rectangle Shape)
+//    round2SameRect (Two Same-side Round Corner Rectangle Shape)
+//    roundRect (Round Corner Rectangle Shape)
+//    rtTriangle (Right Triangle Shape)
+//    smileyFace (Smiley Face Shape)
+//    snip1Rect (One Snip Corner Rectangle Shape)
+//    snip2DiagRect (Two Diagonal Snip Corner Rectangle Shape)
+//    snip2SameRect (Two Same-side Snip Corner Rectangle Shape)
+//    snipRoundRect (One Snip One Round Corner Rectangle Shape)
+//    squareTabs (Square Tabs Shape)
+//    star10 (Ten Pointed Star Shape)
+//    star12 (Twelve Pointed Star Shape)
+//    star16 (Sixteen Pointed Star Shape)
+//    star24 (Twenty Four Pointed Star Shape)
+//    star32 (Thirty Two Pointed Star Shape)
+//    star4 (Four Pointed Star Shape)
+//    star5 (Five Pointed Star Shape)
+//    star6 (Six Pointed Star Shape)
+//    star7 (Seven Pointed Star Shape)
+//    star8 (Eight Pointed Star Shape)
+//    straightConnector1 (Straight Connector 1 Shape)
+//    stripedRightArrow (Striped Right Arrow Shape)
+//    sun (Sun Shape)
+//    swooshArrow (Swoosh Arrow Shape)
+//    teardrop (Teardrop Shape)
+//    trapezoid (Trapezoid Shape)
+//    triangle (Triangle Shape)
+//    upArrow (Up Arrow Shape)
+//    upArrowCallout (Callout Up Arrow Shape)
+//    upDownArrow (Up Down Arrow Shape)
+//    upDownArrowCallout (Callout Up Down Arrow Shape)
+//    uturnArrow (U-Turn Arrow Shape)
+//    verticalScroll (Vertical Scroll Shape)
+//    wave (Wave Shape)
+//    wedgeEllipseCallout (Callout Wedge Ellipse Shape)
+//    wedgeRectCallout (Callout Wedge Rectangle Shape)
+//    wedgeRoundRectCallout (Callout Wedge Round Rectangle Shape)
+//
+// The following shows the type of text underline supported by excelize:
+//
+//    none
+//    words
+//    sng
+//    dbl
+//    heavy
+//    dotted
+//    dottedHeavy
+//    dash
+//    dashHeavy
+//    dashLong
+//    dashLongHeavy
+//    dotDash
+//    dotDashHeavy
+//    dotDotDash
+//    dotDotDashHeavy
+//    wavy
+//    wavyHeavy
+//    wavyDbl
+//
+func (f *File) AddShape(sheet, cell, format string) error {
+	formatSet, err := parseFormatShapeSet(format)
+	if err != nil {
+		return err
+	}
+	// Read sheet data.
+	xlsx := f.workSheetReader(sheet)
+	// Add first shape for given sheet, create xl/drawings/ and xl/drawings/_rels/ folder.
+	drawingID := f.countDrawings() + 1
+	drawingXML := "xl/drawings/drawing" + strconv.Itoa(drawingID) + ".xml"
+	sheetRelationshipsDrawingXML := "../drawings/drawing" + strconv.Itoa(drawingID) + ".xml"
+
+	if xlsx.Drawing != nil {
+		// The worksheet already has a shape or chart relationships, use the relationships drawing ../drawings/drawing%d.xml.
+		sheetRelationshipsDrawingXML = f.getSheetRelationshipsTargetByID(sheet, xlsx.Drawing.RID)
+		drawingID, _ = strconv.Atoi(strings.TrimSuffix(strings.TrimPrefix(sheetRelationshipsDrawingXML, "../drawings/drawing"), ".xml"))
+		drawingXML = strings.Replace(sheetRelationshipsDrawingXML, "..", "xl", -1)
+	} else {
+		// Add first shape for given sheet.
+		rID := f.addSheetRelationships(sheet, SourceRelationshipDrawingML, sheetRelationshipsDrawingXML, "")
+		f.addSheetDrawing(sheet, rID)
+	}
+	f.addDrawingShape(sheet, drawingXML, cell, formatSet)
+	f.addContentTypePart(drawingID, "drawings")
+	return err
+}
+
+// addDrawingShape provides a function to add preset geometry by given sheet,
+// drawingXMLand format sets.
+func (f *File) addDrawingShape(sheet, drawingXML, cell string, formatSet *formatShape) {
+	textUnderlineType := map[string]bool{"none": true, "words": true, "sng": true, "dbl": true, "heavy": true, "dotted": true, "dottedHeavy": true, "dash": true, "dashHeavy": true, "dashLong": true, "dashLongHeavy": true, "dotDash": true, "dotDashHeavy": true, "dotDotDash": true, "dotDotDashHeavy": true, "wavy": true, "wavyHeavy": true, "wavyDbl": true}
+	cell = strings.ToUpper(cell)
+	fromCol := string(strings.Map(letterOnlyMapF, cell))
+	fromRow, _ := strconv.Atoi(strings.Map(intOnlyMapF, cell))
+	row := fromRow - 1
+	col := TitleToNumber(fromCol)
+	width := int(float64(formatSet.Width) * formatSet.Format.XScale)
+	height := int(float64(formatSet.Height) * formatSet.Format.YScale)
+	colStart, rowStart, _, _, colEnd, rowEnd, x2, y2 := f.positionObjectPixels(sheet, col, row, formatSet.Format.OffsetX, formatSet.Format.OffsetY, width, height)
+	content := xlsxWsDr{}
+	content.A = NameSpaceDrawingML
+	content.Xdr = NameSpaceDrawingMLSpreadSheet
+	cNvPrID := f.drawingParser(drawingXML, &content)
+	twoCellAnchor := xdrCellAnchor{}
+	twoCellAnchor.EditAs = formatSet.Format.Positioning
+	from := xlsxFrom{}
+	from.Col = colStart
+	from.ColOff = formatSet.Format.OffsetX * EMU
+	from.Row = rowStart
+	from.RowOff = formatSet.Format.OffsetY * EMU
+	to := xlsxTo{}
+	to.Col = colEnd
+	to.ColOff = x2 * EMU
+	to.Row = rowEnd
+	to.RowOff = y2 * EMU
+	twoCellAnchor.From = &from
+	twoCellAnchor.To = &to
+	shape := xdrSp{
+		NvSpPr: &xdrNvSpPr{
+			CNvPr: &xlsxCNvPr{
+				ID:   cNvPrID,
+				Name: "Shape " + strconv.Itoa(cNvPrID),
+			},
+			CNvSpPr: &xdrCNvSpPr{
+				TxBox: true,
+			},
+		},
+		SpPr: &xlsxSpPr{
+			PrstGeom: xlsxPrstGeom{
+				Prst: formatSet.Type,
+			},
+		},
+		Style: &xdrStyle{
+			LnRef:     setShapeRef(formatSet.Color.Line, 2),
+			FillRef:   setShapeRef(formatSet.Color.Fill, 1),
+			EffectRef: setShapeRef(formatSet.Color.Effect, 0),
+			FontRef: &aFontRef{
+				Idx: "minor",
+				SchemeClr: &attrValString{
+					Val: "tx1",
+				},
+			},
+		},
+		TxBody: &xdrTxBody{
+			BodyPr: &aBodyPr{
+				VertOverflow: "clip",
+				HorzOverflow: "clip",
+				Wrap:         "none",
+				RtlCol:       false,
+				Anchor:       "t",
+			},
+		},
+	}
+	if len(formatSet.Paragraph) < 1 {
+		formatSet.Paragraph = []formatShapeParagraph{
+			{
+				Font: formatFont{
+					Bold:      false,
+					Italic:    false,
+					Underline: "none",
+					Family:    "Calibri",
+					Size:      11,
+					Color:     "#000000",
+				},
+				Text: " ",
+			},
+		}
+	}
+	for _, p := range formatSet.Paragraph {
+		u := p.Font.Underline
+		_, ok := textUnderlineType[u]
+		if !ok {
+			u = "none"
+		}
+		text := p.Text
+		if text == "" {
+			text = " "
+		}
+		paragraph := &aP{
+			R: &aR{
+				RPr: aRPr{
+					I:       p.Font.Italic,
+					B:       p.Font.Bold,
+					Lang:    "en-US",
+					AltLang: "en-US",
+					U:       u,
+					Sz:      p.Font.Size * 100,
+					Latin:   &aLatin{Typeface: p.Font.Family},
+					SolidFill: &aSolidFill{
+						SrgbClr: &attrValString{
+							Val: strings.Replace(strings.ToUpper(p.Font.Color), "#", "", -1),
+						},
+					},
+				},
+				T: text,
+			},
+			EndParaRPr: &aEndParaRPr{
+				Lang: "en-US",
+			},
+		}
+		shape.TxBody.P = append(shape.TxBody.P, paragraph)
+	}
+	twoCellAnchor.Sp = &shape
+	twoCellAnchor.ClientData = &xdrClientData{
+		FLocksWithSheet:  formatSet.Format.FLocksWithSheet,
+		FPrintsWithSheet: formatSet.Format.FPrintsWithSheet,
+	}
+	content.TwoCellAnchor = append(content.TwoCellAnchor, &twoCellAnchor)
+	output, _ := xml.Marshal(content)
+	f.saveFileList(drawingXML, output)
+}
+
+// setShapeRef provides a function to set color with hex model by given actual
+// color value.
+func setShapeRef(color string, i int) *aRef {
+	if color == "" {
+		return &aRef{
+			Idx: 0,
+			ScrgbClr: &aScrgbClr{
+				R: 0,
+				G: 0,
+				B: 0,
+			},
+		}
+	}
+	return &aRef{
+		Idx: i,
+		SrgbClr: &attrValString{
+			Val: strings.Replace(strings.ToUpper(color), "#", "", -1),
+		},
+	}
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/sheet.go

@@ -0,0 +1,669 @@
+package excelize
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"errors"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/mohae/deepcopy"
+)
+
+// NewSheet provides a function to create a new sheet by given worksheet name,
+// when creating a new XLSX file, the default sheet will be create, when you
+// create a new file.
+func (f *File) NewSheet(name string) int {
+	// Check if the worksheet already exists
+	if f.GetSheetIndex(name) != 0 {
+		return f.SheetCount
+	}
+	f.SheetCount++
+	// Update docProps/app.xml
+	f.setAppXML()
+	// Update [Content_Types].xml
+	f.setContentTypes(f.SheetCount)
+	// Create new sheet /xl/worksheets/sheet%d.xml
+	f.setSheet(f.SheetCount, name)
+	// Update xl/_rels/workbook.xml.rels
+	rID := f.addXlsxWorkbookRels(f.SheetCount)
+	// Update xl/workbook.xml
+	f.setWorkbook(name, rID)
+	return f.SheetCount
+}
+
+// contentTypesReader provides a function to get the pointer to the
+// [Content_Types].xml structure after deserialization.
+func (f *File) contentTypesReader() *xlsxTypes {
+	if f.ContentTypes == nil {
+		var content xlsxTypes
+		_ = xml.Unmarshal([]byte(f.readXML("[Content_Types].xml")), &content)
+		f.ContentTypes = &content
+	}
+	return f.ContentTypes
+}
+
+// contentTypesWriter provides a function to save [Content_Types].xml after
+// serialize structure.
+func (f *File) contentTypesWriter() {
+	if f.ContentTypes != nil {
+		output, _ := xml.Marshal(f.ContentTypes)
+		f.saveFileList("[Content_Types].xml", output)
+	}
+}
+
+// workbookReader provides a function to get the pointer to the xl/workbook.xml
+// structure after deserialization.
+func (f *File) workbookReader() *xlsxWorkbook {
+	if f.WorkBook == nil {
+		var content xlsxWorkbook
+		_ = xml.Unmarshal([]byte(f.readXML("xl/workbook.xml")), &content)
+		f.WorkBook = &content
+	}
+	return f.WorkBook
+}
+
+// workbookWriter provides a function to save xl/workbook.xml after serialize
+// structure.
+func (f *File) workbookWriter() {
+	if f.WorkBook != nil {
+		output, _ := xml.Marshal(f.WorkBook)
+		f.saveFileList("xl/workbook.xml", replaceRelationshipsNameSpaceBytes(output))
+	}
+}
+
+// worksheetWriter provides a function to save xl/worksheets/sheet%d.xml after
+// serialize structure.
+func (f *File) worksheetWriter() {
+	for path, sheet := range f.Sheet {
+		if sheet != nil {
+			for k, v := range sheet.SheetData.Row {
+				f.Sheet[path].SheetData.Row[k].C = trimCell(v.C)
+			}
+			output, _ := xml.Marshal(sheet)
+			f.saveFileList(path, replaceWorkSheetsRelationshipsNameSpaceBytes(output))
+			ok := f.checked[path]
+			if ok {
+				f.checked[path] = false
+			}
+		}
+	}
+}
+
+// trimCell provides a function to trim blank cells which created by completeCol.
+func trimCell(column []xlsxC) []xlsxC {
+	col := make([]xlsxC, len(column))
+	i := 0
+	for _, c := range column {
+		if c.S != 0 || c.V != "" || c.F != nil || c.T != "" {
+			col[i] = c
+			i++
+		}
+	}
+	return col[0:i]
+}
+
+// Read and update property of contents type of XLSX.
+func (f *File) setContentTypes(index int) {
+	content := f.contentTypesReader()
+	content.Overrides = append(content.Overrides, xlsxOverride{
+		PartName:    "/xl/worksheets/sheet" + strconv.Itoa(index) + ".xml",
+		ContentType: "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml",
+	})
+}
+
+// Update sheet property by given index.
+func (f *File) setSheet(index int, name string) {
+	var xlsx xlsxWorksheet
+	xlsx.Dimension.Ref = "A1"
+	xlsx.SheetViews.SheetView = append(xlsx.SheetViews.SheetView, xlsxSheetView{
+		WorkbookViewID: 0,
+	})
+	path := "xl/worksheets/sheet" + strconv.Itoa(index) + ".xml"
+	f.sheetMap[trimSheetName(name)] = path
+	f.Sheet[path] = &xlsx
+}
+
+// setWorkbook update workbook property of XLSX. Maximum 31 characters are
+// allowed in sheet title.
+func (f *File) setWorkbook(name string, rid int) {
+	content := f.workbookReader()
+	rID := 0
+	for _, v := range content.Sheets.Sheet {
+		t, _ := strconv.Atoi(v.SheetID)
+		if t > rID {
+			rID = t
+		}
+	}
+	rID++
+	content.Sheets.Sheet = append(content.Sheets.Sheet, xlsxSheet{
+		Name:    trimSheetName(name),
+		SheetID: strconv.Itoa(rID),
+		ID:      "rId" + strconv.Itoa(rid),
+	})
+}
+
+// workbookRelsReader provides a function to read and unmarshal workbook
+// relationships of XLSX file.
+func (f *File) workbookRelsReader() *xlsxWorkbookRels {
+	if f.WorkBookRels == nil {
+		var content xlsxWorkbookRels
+		_ = xml.Unmarshal([]byte(f.readXML("xl/_rels/workbook.xml.rels")), &content)
+		f.WorkBookRels = &content
+	}
+	return f.WorkBookRels
+}
+
+// workbookRelsWriter provides a function to save xl/_rels/workbook.xml.rels after
+// serialize structure.
+func (f *File) workbookRelsWriter() {
+	if f.WorkBookRels != nil {
+		output, _ := xml.Marshal(f.WorkBookRels)
+		f.saveFileList("xl/_rels/workbook.xml.rels", output)
+	}
+}
+
+// addXlsxWorkbookRels update workbook relationships property of XLSX.
+func (f *File) addXlsxWorkbookRels(sheet int) int {
+	content := f.workbookRelsReader()
+	rID := 0
+	for _, v := range content.Relationships {
+		t, _ := strconv.Atoi(strings.TrimPrefix(v.ID, "rId"))
+		if t > rID {
+			rID = t
+		}
+	}
+	rID++
+	ID := bytes.Buffer{}
+	ID.WriteString("rId")
+	ID.WriteString(strconv.Itoa(rID))
+	target := bytes.Buffer{}
+	target.WriteString("worksheets/sheet")
+	target.WriteString(strconv.Itoa(sheet))
+	target.WriteString(".xml")
+	content.Relationships = append(content.Relationships, xlsxWorkbookRelation{
+		ID:     ID.String(),
+		Target: target.String(),
+		Type:   SourceRelationshipWorkSheet,
+	})
+	return rID
+}
+
+// setAppXML update docProps/app.xml file of XML.
+func (f *File) setAppXML() {
+	f.saveFileList("docProps/app.xml", []byte(templateDocpropsApp))
+}
+
+// Some tools that read XLSX files have very strict requirements about the
+// structure of the input XML. In particular both Numbers on the Mac and SAS
+// dislike inline XML namespace declarations, or namespace prefixes that don't
+// match the ones that Excel itself uses. This is a problem because the Go XML
+// library doesn't multiple namespace declarations in a single element of a
+// document. This function is a horrible hack to fix that after the XML
+// marshalling is completed.
+func replaceRelationshipsNameSpaceBytes(workbookMarshal []byte) []byte {
+	oldXmlns := []byte(`<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">`)
+	newXmlns := []byte(`<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="x15" xmlns:x15="http://schemas.microsoft.com/office/spreadsheetml/2010/11/main">`)
+	return bytes.Replace(workbookMarshal, oldXmlns, newXmlns, -1)
+}
+
+// SetActiveSheet provides a function to set default active worksheet of XLSX by
+// given index. Note that active index is different with the index that got by
+// function GetSheetMap, and it should be greater than 0 and less than total
+// worksheet numbers.
+func (f *File) SetActiveSheet(index int) {
+	if index < 1 {
+		index = 1
+	}
+	index--
+	content := f.workbookReader()
+	if len(content.BookViews.WorkBookView) > 0 {
+		content.BookViews.WorkBookView[0].ActiveTab = index
+	} else {
+		content.BookViews.WorkBookView = append(content.BookViews.WorkBookView, xlsxWorkBookView{
+			ActiveTab: index,
+		})
+	}
+	index++
+	for idx, name := range f.GetSheetMap() {
+		xlsx := f.workSheetReader(name)
+		if index == idx {
+			if len(xlsx.SheetViews.SheetView) > 0 {
+				xlsx.SheetViews.SheetView[0].TabSelected = true
+			} else {
+				xlsx.SheetViews.SheetView = append(xlsx.SheetViews.SheetView, xlsxSheetView{
+					TabSelected: true,
+				})
+			}
+		} else {
+			if len(xlsx.SheetViews.SheetView) > 0 {
+				xlsx.SheetViews.SheetView[0].TabSelected = false
+			}
+		}
+	}
+}
+
+// GetActiveSheetIndex provides a function to get active sheet of XLSX. If not
+// found the active sheet will be return integer 0.
+func (f *File) GetActiveSheetIndex() int {
+	buffer := bytes.Buffer{}
+	content := f.workbookReader()
+	for _, v := range content.Sheets.Sheet {
+		xlsx := xlsxWorksheet{}
+		buffer.WriteString("xl/worksheets/sheet")
+		buffer.WriteString(strings.TrimPrefix(v.ID, "rId"))
+		buffer.WriteString(".xml")
+		_ = xml.Unmarshal([]byte(f.readXML(buffer.String())), &xlsx)
+		for _, sheetView := range xlsx.SheetViews.SheetView {
+			if sheetView.TabSelected {
+				ID, _ := strconv.Atoi(strings.TrimPrefix(v.ID, "rId"))
+				return ID
+			}
+		}
+		buffer.Reset()
+	}
+	return 0
+}
+
+// SetSheetName provides a function to set the worksheet name be given old and new
+// worksheet name. Maximum 31 characters are allowed in sheet title and this
+// function only changes the name of the sheet and will not update the sheet
+// name in the formula or reference associated with the cell. So there may be
+// problem formula error or reference missing.
+func (f *File) SetSheetName(oldName, newName string) {
+	oldName = trimSheetName(oldName)
+	newName = trimSheetName(newName)
+	content := f.workbookReader()
+	for k, v := range content.Sheets.Sheet {
+		if v.Name == oldName {
+			content.Sheets.Sheet[k].Name = newName
+			f.sheetMap[newName] = f.sheetMap[oldName]
+			delete(f.sheetMap, oldName)
+		}
+	}
+}
+
+// GetSheetName provides a function to get worksheet name of XLSX by given
+// worksheet index. If given sheet index is invalid, will return an empty
+// string.
+func (f *File) GetSheetName(index int) string {
+	content := f.workbookReader()
+	rels := f.workbookRelsReader()
+	for _, rel := range rels.Relationships {
+		rID, _ := strconv.Atoi(strings.TrimSuffix(strings.TrimPrefix(rel.Target, "worksheets/sheet"), ".xml"))
+		if rID == index {
+			for _, v := range content.Sheets.Sheet {
+				if v.ID == rel.ID {
+					return v.Name
+				}
+			}
+		}
+	}
+	return ""
+}
+
+// GetSheetIndex provides a function to get worksheet index of XLSX by given sheet
+// name. If given worksheet name is invalid, will return an integer type value
+// 0.
+func (f *File) GetSheetIndex(name string) int {
+	content := f.workbookReader()
+	rels := f.workbookRelsReader()
+	for _, v := range content.Sheets.Sheet {
+		if v.Name == name {
+			for _, rel := range rels.Relationships {
+				if v.ID == rel.ID {
+					rID, _ := strconv.Atoi(strings.TrimSuffix(strings.TrimPrefix(rel.Target, "worksheets/sheet"), ".xml"))
+					return rID
+				}
+			}
+		}
+	}
+	return 0
+}
+
+// GetSheetMap provides a function to get worksheet name and index map of XLSX.
+// For example:
+//
+//    xlsx, err := excelize.OpenFile("./Book1.xlsx")
+//    if err != nil {
+//        return
+//    }
+//    for index, name := range xlsx.GetSheetMap() {
+//        fmt.Println(index, name)
+//    }
+//
+func (f *File) GetSheetMap() map[int]string {
+	content := f.workbookReader()
+	rels := f.workbookRelsReader()
+	sheetMap := map[int]string{}
+	for _, v := range content.Sheets.Sheet {
+		for _, rel := range rels.Relationships {
+			if rel.ID == v.ID {
+				rID, _ := strconv.Atoi(strings.TrimSuffix(strings.TrimPrefix(rel.Target, "worksheets/sheet"), ".xml"))
+				sheetMap[rID] = v.Name
+			}
+		}
+	}
+	return sheetMap
+}
+
+// getSheetMap provides a function to get worksheet name and XML file path map of
+// XLSX.
+func (f *File) getSheetMap() map[string]string {
+	maps := make(map[string]string)
+	for idx, name := range f.GetSheetMap() {
+		maps[name] = "xl/worksheets/sheet" + strconv.Itoa(idx) + ".xml"
+	}
+	return maps
+}
+
+// SetSheetBackground provides a function to set background picture by given
+// worksheet name.
+func (f *File) SetSheetBackground(sheet, picture string) error {
+	var err error
+	// Check picture exists first.
+	if _, err = os.Stat(picture); os.IsNotExist(err) {
+		return err
+	}
+	ext, ok := supportImageTypes[path.Ext(picture)]
+	if !ok {
+		return errors.New("Unsupported image extension")
+	}
+	pictureID := f.countMedia() + 1
+	rID := f.addSheetRelationships(sheet, SourceRelationshipImage, "../media/image"+strconv.Itoa(pictureID)+ext, "")
+	f.addSheetPicture(sheet, rID)
+	f.addMedia(picture, ext)
+	f.setContentTypePartImageExtensions()
+	return err
+}
+
+// DeleteSheet provides a function to delete worksheet in a workbook by given
+// worksheet name. Use this method with caution, which will affect changes in
+// references such as formulas, charts, and so on. If there is any referenced
+// value of the deleted worksheet, it will cause a file error when you open it.
+// This function will be invalid when only the one worksheet is left.
+func (f *File) DeleteSheet(name string) {
+	content := f.workbookReader()
+	for k, v := range content.Sheets.Sheet {
+		if v.Name == trimSheetName(name) && len(content.Sheets.Sheet) > 1 {
+			content.Sheets.Sheet = append(content.Sheets.Sheet[:k], content.Sheets.Sheet[k+1:]...)
+			sheet := "xl/worksheets/sheet" + strings.TrimPrefix(v.ID, "rId") + ".xml"
+			rels := "xl/worksheets/_rels/sheet" + strings.TrimPrefix(v.ID, "rId") + ".xml.rels"
+			target := f.deleteSheetFromWorkbookRels(v.ID)
+			f.deleteSheetFromContentTypes(target)
+			delete(f.sheetMap, name)
+			delete(f.XLSX, sheet)
+			delete(f.XLSX, rels)
+			delete(f.Sheet, sheet)
+			f.SheetCount--
+		}
+	}
+	f.SetActiveSheet(len(f.GetSheetMap()))
+}
+
+// deleteSheetFromWorkbookRels provides a function to remove worksheet
+// relationships by given relationships ID in the file
+// xl/_rels/workbook.xml.rels.
+func (f *File) deleteSheetFromWorkbookRels(rID string) string {
+	content := f.workbookRelsReader()
+	for k, v := range content.Relationships {
+		if v.ID == rID {
+			content.Relationships = append(content.Relationships[:k], content.Relationships[k+1:]...)
+			return v.Target
+		}
+	}
+	return ""
+}
+
+// deleteSheetFromContentTypes provides a function to remove worksheet
+// relationships by given target name in the file [Content_Types].xml.
+func (f *File) deleteSheetFromContentTypes(target string) {
+	content := f.contentTypesReader()
+	for k, v := range content.Overrides {
+		if v.PartName == "/xl/"+target {
+			content.Overrides = append(content.Overrides[:k], content.Overrides[k+1:]...)
+		}
+	}
+}
+
+// CopySheet provides a function to duplicate a worksheet by gave source and
+// target worksheet index. Note that currently doesn't support duplicate
+// workbooks that contain tables, charts or pictures. For Example:
+//
+//    // Sheet1 already exists...
+//    index := xlsx.NewSheet("Sheet2")
+//    err := xlsx.CopySheet(1, index)
+//    return err
+//
+func (f *File) CopySheet(from, to int) error {
+	if from < 1 || to < 1 || from == to || f.GetSheetName(from) == "" || f.GetSheetName(to) == "" {
+		return errors.New("Invalid worksheet index")
+	}
+	f.copySheet(from, to)
+	return nil
+}
+
+// copySheet provides a function to duplicate a worksheet by gave source and
+// target worksheet name.
+func (f *File) copySheet(from, to int) {
+	sheet := f.workSheetReader("sheet" + strconv.Itoa(from))
+	worksheet := deepcopy.Copy(sheet).(*xlsxWorksheet)
+	path := "xl/worksheets/sheet" + strconv.Itoa(to) + ".xml"
+	if len(worksheet.SheetViews.SheetView) > 0 {
+		worksheet.SheetViews.SheetView[0].TabSelected = false
+	}
+	worksheet.Drawing = nil
+	worksheet.TableParts = nil
+	worksheet.PageSetUp = nil
+	f.Sheet[path] = worksheet
+	toRels := "xl/worksheets/_rels/sheet" + strconv.Itoa(to) + ".xml.rels"
+	fromRels := "xl/worksheets/_rels/sheet" + strconv.Itoa(from) + ".xml.rels"
+	_, ok := f.XLSX[fromRels]
+	if ok {
+		f.XLSX[toRels] = f.XLSX[fromRels]
+	}
+}
+
+// SetSheetVisible provides a function to set worksheet visible by given worksheet
+// name. A workbook must contain at least one visible worksheet. If the given
+// worksheet has been activated, this setting will be invalidated. Sheet state
+// values as defined by http://msdn.microsoft.com/en-us/library/office/documentformat.openxml.spreadsheet.sheetstatevalues.aspx
+//
+//    visible
+//    hidden
+//    veryHidden
+//
+// For example, hide Sheet1:
+//
+//    xlsx.SetSheetVisible("Sheet1", false)
+//
+func (f *File) SetSheetVisible(name string, visible bool) {
+	name = trimSheetName(name)
+	content := f.workbookReader()
+	if visible {
+		for k, v := range content.Sheets.Sheet {
+			if v.Name == name {
+				content.Sheets.Sheet[k].State = ""
+			}
+		}
+		return
+	}
+	count := 0
+	for _, v := range content.Sheets.Sheet {
+		if v.State != "hidden" {
+			count++
+		}
+	}
+	for k, v := range content.Sheets.Sheet {
+		xlsx := f.workSheetReader(f.GetSheetMap()[k])
+		tabSelected := false
+		if len(xlsx.SheetViews.SheetView) > 0 {
+			tabSelected = xlsx.SheetViews.SheetView[0].TabSelected
+		}
+		if v.Name == name && count > 1 && !tabSelected {
+			content.Sheets.Sheet[k].State = "hidden"
+		}
+	}
+}
+
+// parseFormatPanesSet provides a function to parse the panes settings.
+func parseFormatPanesSet(formatSet string) (*formatPanes, error) {
+	format := formatPanes{}
+	err := json.Unmarshal([]byte(formatSet), &format)
+	return &format, err
+}
+
+// SetPanes provides a function to create and remove freeze panes and split panes
+// by given worksheet name and panes format set.
+//
+// activePane defines the pane that is active. The possible values for this
+// attribute are defined in the following table:
+//
+//     Enumeration Value              | Description
+//    --------------------------------+-------------------------------------------------------------
+//     bottomLeft (Bottom Left Pane)  | Bottom left pane, when both vertical and horizontal
+//                                    | splits are applied.
+//                                    |
+//                                    | This value is also used when only a horizontal split has
+//                                    | been applied, dividing the pane into upper and lower
+//                                    | regions. In that case, this value specifies the bottom
+//                                    | pane.
+//                                    |
+//    bottomRight (Bottom Right Pane) | Bottom right pane, when both vertical and horizontal
+//                                    | splits are applied.
+//                                    |
+//    topLeft (Top Left Pane)         | Top left pane, when both vertical and horizontal splits
+//                                    | are applied.
+//                                    |
+//                                    | This value is also used when only a horizontal split has
+//                                    | been applied, dividing the pane into upper and lower
+//                                    | regions. In that case, this value specifies the top pane.
+//                                    |
+//                                    | This value is also used when only a vertical split has
+//                                    | been applied, dividing the pane into right and left
+//                                    | regions. In that case, this value specifies the left pane
+//                                    |
+//    topRight (Top Right Pane)       | Top right pane, when both vertical and horizontal
+//                                    | splits are applied.
+//                                    |
+//                                    | This value is also used when only a vertical split has
+//                                    | been applied, dividing the pane into right and left
+//                                    | regions. In that case, this value specifies the right
+//                                    | pane.
+//
+// Pane state type is restricted to the values supported currently listed in the following table:
+//
+//     Enumeration Value              | Description
+//    --------------------------------+-------------------------------------------------------------
+//     frozen (Frozen)                | Panes are frozen, but were not split being frozen. In
+//                                    | this state, when the panes are unfrozen again, a single
+//                                    | pane results, with no split.
+//                                    |
+//                                    | In this state, the split bars are not adjustable.
+//                                    |
+//     split (Split)                  | Panes are split, but not frozen. In this state, the split
+//                                    | bars are adjustable by the user.
+//
+// x_split (Horizontal Split Position): Horizontal position of the split, in
+// 1/20th of a point; 0 (zero) if none. If the pane is frozen, this value
+// indicates the number of columns visible in the top pane.
+//
+// y_split (Vertical Split Position): Vertical position of the split, in 1/20th
+// of a point; 0 (zero) if none. If the pane is frozen, this value indicates the
+// number of rows visible in the left pane. The possible values for this
+// attribute are defined by the W3C XML Schema double datatype.
+//
+// top_left_cell: Location of the top left visible cell in the bottom right pane
+// (when in Left-To-Right mode).
+//
+// sqref (Sequence of References): Range of the selection. Can be non-contiguous
+// set of ranges.
+//
+// An example of how to freeze column A in the Sheet1 and set the active cell on
+// Sheet1!K16:
+//
+//    xlsx.SetPanes("Sheet1", `{"freeze":true,"split":false,"x_split":1,"y_split":0,"top_left_cell":"B1","active_pane":"topRight","panes":[{"sqref":"K16","active_cell":"K16","pane":"topRight"}]}`)
+//
+// An example of how to freeze rows 1 to 9 in the Sheet1 and set the active cell
+// ranges on Sheet1!A11:XFD11:
+//
+//    xlsx.SetPanes("Sheet1", `{"freeze":true,"split":false,"x_split":0,"y_split":9,"top_left_cell":"A34","active_pane":"bottomLeft","panes":[{"sqref":"A11:XFD11","active_cell":"A11","pane":"bottomLeft"}]}`)
+//
+// An example of how to create split panes in the Sheet1 and set the active cell
+// on Sheet1!J60:
+//
+//    xlsx.SetPanes("Sheet1", `{"freeze":false,"split":true,"x_split":3270,"y_split":1800,"top_left_cell":"N57","active_pane":"bottomLeft","panes":[{"sqref":"I36","active_cell":"I36"},{"sqref":"G33","active_cell":"G33","pane":"topRight"},{"sqref":"J60","active_cell":"J60","pane":"bottomLeft"},{"sqref":"O60","active_cell":"O60","pane":"bottomRight"}]}`)
+//
+// An example of how to unfreeze and remove all panes on Sheet1:
+//
+//    xlsx.SetPanes("Sheet1", `{"freeze":false,"split":false}`)
+//
+func (f *File) SetPanes(sheet, panes string) {
+	fs, _ := parseFormatPanesSet(panes)
+	xlsx := f.workSheetReader(sheet)
+	p := &xlsxPane{
+		ActivePane:  fs.ActivePane,
+		TopLeftCell: fs.TopLeftCell,
+		XSplit:      float64(fs.XSplit),
+		YSplit:      float64(fs.YSplit),
+	}
+	if fs.Freeze {
+		p.State = "frozen"
+	}
+	xlsx.SheetViews.SheetView[len(xlsx.SheetViews.SheetView)-1].Pane = p
+	if !(fs.Freeze) && !(fs.Split) {
+		if len(xlsx.SheetViews.SheetView) > 0 {
+			xlsx.SheetViews.SheetView[len(xlsx.SheetViews.SheetView)-1].Pane = nil
+		}
+	}
+	s := []*xlsxSelection{}
+	for _, p := range fs.Panes {
+		s = append(s, &xlsxSelection{
+			ActiveCell: p.ActiveCell,
+			Pane:       p.Pane,
+			SQRef:      p.SQRef,
+		})
+	}
+	xlsx.SheetViews.SheetView[len(xlsx.SheetViews.SheetView)-1].Selection = s
+}
+
+// GetSheetVisible provides a function to get worksheet visible by given worksheet
+// name. For example, get visible state of Sheet1:
+//
+//    xlsx.GetSheetVisible("Sheet1")
+//
+func (f *File) GetSheetVisible(name string) bool {
+	content := f.workbookReader()
+	visible := false
+	for k, v := range content.Sheets.Sheet {
+		if v.Name == trimSheetName(name) {
+			if content.Sheets.Sheet[k].State == "" || content.Sheets.Sheet[k].State == "visible" {
+				visible = true
+			}
+		}
+	}
+	return visible
+}
+
+// trimSheetName provides a function to trim invaild characters by given worksheet
+// name.
+func trimSheetName(name string) string {
+	r := []rune{}
+	for _, v := range name {
+		switch v {
+		case 58, 92, 47, 63, 42, 91, 93: // replace :\/?*[]
+			continue
+		default:
+			r = append(r, v)
+		}
+	}
+	name = string(r)
+	if utf8.RuneCountInString(name) > 31 {
+		name = string([]rune(name)[0:31])
+	}
+	return name
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/sheetpr.go

@@ -0,0 +1,139 @@
+package excelize
+
+// SheetPrOption is an option of a view of a worksheet. See SetSheetPrOptions().
+type SheetPrOption interface {
+	setSheetPrOption(view *xlsxSheetPr)
+}
+
+// SheetPrOptionPtr is a writable SheetPrOption. See GetSheetPrOptions().
+type SheetPrOptionPtr interface {
+	SheetPrOption
+	getSheetPrOption(view *xlsxSheetPr)
+}
+
+type (
+	// CodeName is a SheetPrOption
+	CodeName string
+	// EnableFormatConditionsCalculation is a SheetPrOption
+	EnableFormatConditionsCalculation bool
+	// Published is a SheetPrOption
+	Published bool
+	// FitToPage is a SheetPrOption
+	FitToPage bool
+	// AutoPageBreaks is a SheetPrOption
+	AutoPageBreaks bool
+)
+
+func (o CodeName) setSheetPrOption(pr *xlsxSheetPr) {
+	pr.CodeName = string(o)
+}
+
+func (o *CodeName) getSheetPrOption(pr *xlsxSheetPr) {
+	if pr == nil {
+		*o = ""
+		return
+	}
+	*o = CodeName(pr.CodeName)
+}
+
+func (o EnableFormatConditionsCalculation) setSheetPrOption(pr *xlsxSheetPr) {
+	pr.EnableFormatConditionsCalculation = boolPtr(bool(o))
+}
+
+func (o *EnableFormatConditionsCalculation) getSheetPrOption(pr *xlsxSheetPr) {
+	if pr == nil {
+		*o = true
+		return
+	}
+	*o = EnableFormatConditionsCalculation(defaultTrue(pr.EnableFormatConditionsCalculation))
+}
+
+func (o Published) setSheetPrOption(pr *xlsxSheetPr) {
+	pr.Published = boolPtr(bool(o))
+}
+
+func (o *Published) getSheetPrOption(pr *xlsxSheetPr) {
+	if pr == nil {
+		*o = true
+		return
+	}
+	*o = Published(defaultTrue(pr.Published))
+}
+
+func (o FitToPage) setSheetPrOption(pr *xlsxSheetPr) {
+	if pr.PageSetUpPr == nil {
+		if !o {
+			return
+		}
+		pr.PageSetUpPr = new(xlsxPageSetUpPr)
+	}
+	pr.PageSetUpPr.FitToPage = bool(o)
+}
+
+func (o *FitToPage) getSheetPrOption(pr *xlsxSheetPr) {
+	// Excel default: false
+	if pr == nil || pr.PageSetUpPr == nil {
+		*o = false
+		return
+	}
+	*o = FitToPage(pr.PageSetUpPr.FitToPage)
+}
+
+func (o AutoPageBreaks) setSheetPrOption(pr *xlsxSheetPr) {
+	if pr.PageSetUpPr == nil {
+		if !o {
+			return
+		}
+		pr.PageSetUpPr = new(xlsxPageSetUpPr)
+	}
+	pr.PageSetUpPr.AutoPageBreaks = bool(o)
+}
+
+func (o *AutoPageBreaks) getSheetPrOption(pr *xlsxSheetPr) {
+	// Excel default: false
+	if pr == nil || pr.PageSetUpPr == nil {
+		*o = false
+		return
+	}
+	*o = AutoPageBreaks(pr.PageSetUpPr.AutoPageBreaks)
+}
+
+// SetSheetPrOptions provides a function to sets worksheet properties.
+//
+// Available options:
+//   CodeName(string)
+//   EnableFormatConditionsCalculation(bool)
+//   Published(bool)
+//   FitToPage(bool)
+//   AutoPageBreaks(bool)
+func (f *File) SetSheetPrOptions(name string, opts ...SheetPrOption) error {
+	sheet := f.workSheetReader(name)
+	pr := sheet.SheetPr
+	if pr == nil {
+		pr = new(xlsxSheetPr)
+		sheet.SheetPr = pr
+	}
+
+	for _, opt := range opts {
+		opt.setSheetPrOption(pr)
+	}
+	return nil
+}
+
+// GetSheetPrOptions provides a function to gets worksheet properties.
+//
+// Available options:
+//   CodeName(string)
+//   EnableFormatConditionsCalculation(bool)
+//   Published(bool)
+//   FitToPage(bool)
+//   AutoPageBreaks(bool)
+func (f *File) GetSheetPrOptions(name string, opts ...SheetPrOptionPtr) error {
+	sheet := f.workSheetReader(name)
+	pr := sheet.SheetPr
+
+	for _, opt := range opts {
+		opt.getSheetPrOption(pr)
+	}
+	return nil
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/sheetview.go

@@ -0,0 +1,152 @@
+package excelize
+
+import "fmt"
+
+// SheetViewOption is an option of a view of a worksheet. See SetSheetViewOptions().
+type SheetViewOption interface {
+	setSheetViewOption(view *xlsxSheetView)
+}
+
+// SheetViewOptionPtr is a writable SheetViewOption. See GetSheetViewOptions().
+type SheetViewOptionPtr interface {
+	SheetViewOption
+	getSheetViewOption(view *xlsxSheetView)
+}
+
+type (
+	// DefaultGridColor is a SheetViewOption.
+	DefaultGridColor bool
+	// RightToLeft is a SheetViewOption.
+	RightToLeft bool
+	// ShowFormulas is a SheetViewOption.
+	ShowFormulas bool
+	// ShowGridLines is a SheetViewOption.
+	ShowGridLines bool
+	// ShowRowColHeaders is a SheetViewOption.
+	ShowRowColHeaders bool
+	// ZoomScale is a SheetViewOption.
+	ZoomScale float64
+	/* TODO
+	// ShowWhiteSpace is a SheetViewOption.
+	ShowWhiteSpace bool
+	// ShowZeros is a SheetViewOption.
+	ShowZeros bool
+	// WindowProtection is a SheetViewOption.
+	WindowProtection bool
+	*/
+)
+
+// Defaults for each option are described in XML schema for CT_SheetView
+
+func (o DefaultGridColor) setSheetViewOption(view *xlsxSheetView) {
+	view.DefaultGridColor = boolPtr(bool(o))
+}
+
+func (o *DefaultGridColor) getSheetViewOption(view *xlsxSheetView) {
+	*o = DefaultGridColor(defaultTrue(view.DefaultGridColor)) // Excel default: true
+}
+
+func (o RightToLeft) setSheetViewOption(view *xlsxSheetView) {
+	view.RightToLeft = bool(o) // Excel default: false
+}
+
+func (o *RightToLeft) getSheetViewOption(view *xlsxSheetView) {
+	*o = RightToLeft(view.RightToLeft)
+}
+
+func (o ShowFormulas) setSheetViewOption(view *xlsxSheetView) {
+	view.ShowFormulas = bool(o) // Excel default: false
+}
+
+func (o *ShowFormulas) getSheetViewOption(view *xlsxSheetView) {
+	*o = ShowFormulas(view.ShowFormulas) // Excel default: false
+}
+
+func (o ShowGridLines) setSheetViewOption(view *xlsxSheetView) {
+	view.ShowGridLines = boolPtr(bool(o))
+}
+
+func (o *ShowGridLines) getSheetViewOption(view *xlsxSheetView) {
+	*o = ShowGridLines(defaultTrue(view.ShowGridLines)) // Excel default: true
+}
+
+func (o ShowRowColHeaders) setSheetViewOption(view *xlsxSheetView) {
+	view.ShowRowColHeaders = boolPtr(bool(o))
+}
+
+func (o *ShowRowColHeaders) getSheetViewOption(view *xlsxSheetView) {
+	*o = ShowRowColHeaders(defaultTrue(view.ShowRowColHeaders)) // Excel default: true
+}
+
+func (o ZoomScale) setSheetViewOption(view *xlsxSheetView) {
+	//This attribute is restricted to values ranging from 10 to 400.
+	if float64(o) >= 10 && float64(o) <= 400 {
+		view.ZoomScale = float64(o)
+	}
+}
+
+func (o *ZoomScale) getSheetViewOption(view *xlsxSheetView) {
+	*o = ZoomScale(view.ZoomScale)
+}
+
+// getSheetView returns the SheetView object
+func (f *File) getSheetView(sheetName string, viewIndex int) (*xlsxSheetView, error) {
+	xlsx := f.workSheetReader(sheetName)
+	if viewIndex < 0 {
+		if viewIndex < -len(xlsx.SheetViews.SheetView) {
+			return nil, fmt.Errorf("view index %d out of range", viewIndex)
+		}
+		viewIndex = len(xlsx.SheetViews.SheetView) + viewIndex
+	} else if viewIndex >= len(xlsx.SheetViews.SheetView) {
+		return nil, fmt.Errorf("view index %d out of range", viewIndex)
+	}
+
+	return &(xlsx.SheetViews.SheetView[viewIndex]), nil
+}
+
+// SetSheetViewOptions sets sheet view options.
+// The viewIndex may be negative and if so is counted backward (-1 is the last view).
+//
+// Available options:
+//    DefaultGridColor(bool)
+//    RightToLeft(bool)
+//    ShowFormulas(bool)
+//    ShowGridLines(bool)
+//    ShowRowColHeaders(bool)
+// Example:
+//    err = f.SetSheetViewOptions("Sheet1", -1, ShowGridLines(false))
+func (f *File) SetSheetViewOptions(name string, viewIndex int, opts ...SheetViewOption) error {
+	view, err := f.getSheetView(name, viewIndex)
+	if err != nil {
+		return err
+	}
+
+	for _, opt := range opts {
+		opt.setSheetViewOption(view)
+	}
+	return nil
+}
+
+// GetSheetViewOptions gets the value of sheet view options.
+// The viewIndex may be negative and if so is counted backward (-1 is the last view).
+//
+// Available options:
+//    DefaultGridColor(bool)
+//    RightToLeft(bool)
+//    ShowFormulas(bool)
+//    ShowGridLines(bool)
+//    ShowRowColHeaders(bool)
+// Example:
+//    var showGridLines excelize.ShowGridLines
+//    err = f.GetSheetViewOptions("Sheet1", -1, &showGridLines)
+func (f *File) GetSheetViewOptions(name string, viewIndex int, opts ...SheetViewOptionPtr) error {
+	view, err := f.getSheetView(name, viewIndex)
+	if err != nil {
+		return err
+	}
+
+	for _, opt := range opts {
+		opt.getSheetViewOption(view)
+	}
+	return nil
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/table.go

@@ -0,0 +1,452 @@
+package excelize
+
+import (
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+// parseFormatTableSet provides a function to parse the format settings of the
+// table with default value.
+func parseFormatTableSet(formatSet string) (*formatTable, error) {
+	format := formatTable{
+		TableStyle:     "",
+		ShowRowStripes: true,
+	}
+	err := json.Unmarshal(parseFormatSet(formatSet), &format)
+	return &format, err
+}
+
+// AddTable provides the method to add table in a worksheet by given worksheet
+// name, coordinate area and format set. For example, create a table of A1:D5
+// on Sheet1:
+//
+//    xlsx.AddTable("Sheet1", "A1", "D5", ``)
+//
+// Create a table of F2:H6 on Sheet2 with format set:
+//
+//    xlsx.AddTable("Sheet2", "F2", "H6", `{"table_name":"table","table_style":"TableStyleMedium2", "show_first_column":true,"show_last_column":true,"show_row_stripes":false,"show_column_stripes":true}`)
+//
+// Note that the table at least two lines include string type header. Multiple
+// tables coordinate areas can't have an intersection.
+//
+// table_name: The name of the table, in the same worksheet name of the table should be unique
+//
+// table_style: The built-in table style names
+//
+//    TableStyleLight1 - TableStyleLight21
+//    TableStyleMedium1 - TableStyleMedium28
+//    TableStyleDark1 - TableStyleDark11
+//
+func (f *File) AddTable(sheet, hcell, vcell, format string) error {
+	formatSet, err := parseFormatTableSet(format)
+	if err != nil {
+		return err
+	}
+	hcell = strings.ToUpper(hcell)
+	vcell = strings.ToUpper(vcell)
+	// Coordinate conversion, convert C1:B3 to 2,0,1,2.
+	hcol := string(strings.Map(letterOnlyMapF, hcell))
+	hrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, hcell))
+	hyAxis := hrow - 1
+	hxAxis := TitleToNumber(hcol)
+
+	vcol := string(strings.Map(letterOnlyMapF, vcell))
+	vrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, vcell))
+	vyAxis := vrow - 1
+	vxAxis := TitleToNumber(vcol)
+	if vxAxis < hxAxis {
+		vxAxis, hxAxis = hxAxis, vxAxis
+	}
+	if vyAxis < hyAxis {
+		vyAxis, hyAxis = hyAxis, vyAxis
+	}
+	tableID := f.countTables() + 1
+	sheetRelationshipsTableXML := "../tables/table" + strconv.Itoa(tableID) + ".xml"
+	tableXML := strings.Replace(sheetRelationshipsTableXML, "..", "xl", -1)
+	// Add first table for given sheet.
+	rID := f.addSheetRelationships(sheet, SourceRelationshipTable, sheetRelationshipsTableXML, "")
+	f.addSheetTable(sheet, rID)
+	f.addTable(sheet, tableXML, hxAxis, hyAxis, vxAxis, vyAxis, tableID, formatSet)
+	f.addContentTypePart(tableID, "table")
+	return err
+}
+
+// countTables provides a function to get table files count storage in the
+// folder xl/tables.
+func (f *File) countTables() int {
+	count := 0
+	for k := range f.XLSX {
+		if strings.Contains(k, "xl/tables/table") {
+			count++
+		}
+	}
+	return count
+}
+
+// addSheetTable provides a function to add tablePart element to
+// xl/worksheets/sheet%d.xml by given worksheet name and relationship index.
+func (f *File) addSheetTable(sheet string, rID int) {
+	xlsx := f.workSheetReader(sheet)
+	table := &xlsxTablePart{
+		RID: "rId" + strconv.Itoa(rID),
+	}
+	if xlsx.TableParts == nil {
+		xlsx.TableParts = &xlsxTableParts{}
+	}
+	xlsx.TableParts.Count++
+	xlsx.TableParts.TableParts = append(xlsx.TableParts.TableParts, table)
+}
+
+// addTable provides a function to add table by given worksheet name,
+// coordinate area and format set.
+func (f *File) addTable(sheet, tableXML string, hxAxis, hyAxis, vxAxis, vyAxis, i int, formatSet *formatTable) {
+	// Correct the minimum number of rows, the table at least two lines.
+	if hyAxis == vyAxis {
+		vyAxis++
+	}
+	// Correct table reference coordinate area, such correct C1:B3 to B1:C3.
+	ref := ToAlphaString(hxAxis) + strconv.Itoa(hyAxis+1) + ":" + ToAlphaString(vxAxis) + strconv.Itoa(vyAxis+1)
+	tableColumn := []*xlsxTableColumn{}
+	idx := 0
+	for i := hxAxis; i <= vxAxis; i++ {
+		idx++
+		cell := ToAlphaString(i) + strconv.Itoa(hyAxis+1)
+		name := f.GetCellValue(sheet, cell)
+		if _, err := strconv.Atoi(name); err == nil {
+			f.SetCellStr(sheet, cell, name)
+		}
+		if name == "" {
+			name = "Column" + strconv.Itoa(idx)
+			f.SetCellStr(sheet, cell, name)
+		}
+		tableColumn = append(tableColumn, &xlsxTableColumn{
+			ID:   idx,
+			Name: name,
+		})
+	}
+	name := formatSet.TableName
+	if name == "" {
+		name = "Table" + strconv.Itoa(i)
+	}
+	t := xlsxTable{
+		XMLNS:       NameSpaceSpreadSheet,
+		ID:          i,
+		Name:        name,
+		DisplayName: name,
+		Ref:         ref,
+		AutoFilter: &xlsxAutoFilter{
+			Ref: ref,
+		},
+		TableColumns: &xlsxTableColumns{
+			Count:       idx,
+			TableColumn: tableColumn,
+		},
+		TableStyleInfo: &xlsxTableStyleInfo{
+			Name:              formatSet.TableStyle,
+			ShowFirstColumn:   formatSet.ShowFirstColumn,
+			ShowLastColumn:    formatSet.ShowLastColumn,
+			ShowRowStripes:    formatSet.ShowRowStripes,
+			ShowColumnStripes: formatSet.ShowColumnStripes,
+		},
+	}
+	table, _ := xml.Marshal(t)
+	f.saveFileList(tableXML, table)
+}
+
+// parseAutoFilterSet provides a function to parse the settings of the auto
+// filter.
+func parseAutoFilterSet(formatSet string) (*formatAutoFilter, error) {
+	format := formatAutoFilter{}
+	err := json.Unmarshal([]byte(formatSet), &format)
+	return &format, err
+}
+
+// AutoFilter provides the method to add auto filter in a worksheet by given
+// worksheet name, coordinate area and settings. An autofilter in Excel is a
+// way of filtering a 2D range of data based on some simple criteria. For
+// example applying an autofilter to a cell range A1:D4 in the Sheet1:
+//
+//    err = xlsx.AutoFilter("Sheet1", "A1", "D4", "")
+//
+// Filter data in an autofilter:
+//
+//    err = xlsx.AutoFilter("Sheet1", "A1", "D4", `{"column":"B","expression":"x != blanks"}`)
+//
+// column defines the filter columns in a autofilter range based on simple
+// criteria
+//
+// It isn't sufficient to just specify the filter condition. You must also
+// hide any rows that don't match the filter condition. Rows are hidden using
+// the SetRowVisible() method. Excelize can't filter rows automatically since
+// this isn't part of the file format.
+//
+// Setting a filter criteria for a column:
+//
+// expression defines the conditions, the following operators are available
+// for setting the filter criteria:
+//
+//    ==
+//    !=
+//    >
+//    <
+//    >=
+//    <=
+//    and
+//    or
+//
+// An expression can comprise a single statement or two statements separated
+// by the 'and' and 'or' operators. For example:
+//
+//    x <  2000
+//    x >  2000
+//    x == 2000
+//    x >  2000 and x <  5000
+//    x == 2000 or  x == 5000
+//
+// Filtering of blank or non-blank data can be achieved by using a value of
+// Blanks or NonBlanks in the expression:
+//
+//    x == Blanks
+//    x == NonBlanks
+//
+// Excel also allows some simple string matching operations:
+//
+//    x == b*      // begins with b
+//    x != b*      // doesnt begin with b
+//    x == *b      // ends with b
+//    x != *b      // doesnt end with b
+//    x == *b*     // contains b
+//    x != *b*     // doesn't contains b
+//
+// You can also use '*' to match any character or number and '?' to match any
+// single character or number. No other regular expression quantifier is
+// supported by Excel's filters. Excel's regular expression characters can be
+// escaped using '~'.
+//
+// The placeholder variable x in the above examples can be replaced by any
+// simple string. The actual placeholder name is ignored internally so the
+// following are all equivalent:
+//
+//    x     < 2000
+//    col   < 2000
+//    Price < 2000
+//
+func (f *File) AutoFilter(sheet, hcell, vcell, format string) error {
+	formatSet, _ := parseAutoFilterSet(format)
+
+	hcell = strings.ToUpper(hcell)
+	vcell = strings.ToUpper(vcell)
+
+	// Coordinate conversion, convert C1:B3 to 2,0,1,2.
+	hcol := string(strings.Map(letterOnlyMapF, hcell))
+	hrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, hcell))
+	hyAxis := hrow - 1
+	hxAxis := TitleToNumber(hcol)
+
+	vcol := string(strings.Map(letterOnlyMapF, vcell))
+	vrow, _ := strconv.Atoi(strings.Map(intOnlyMapF, vcell))
+	vyAxis := vrow - 1
+	vxAxis := TitleToNumber(vcol)
+
+	if vxAxis < hxAxis {
+		vxAxis, hxAxis = hxAxis, vxAxis
+	}
+
+	if vyAxis < hyAxis {
+		vyAxis, hyAxis = hyAxis, vyAxis
+	}
+	ref := ToAlphaString(hxAxis) + strconv.Itoa(hyAxis+1) + ":" + ToAlphaString(vxAxis) + strconv.Itoa(vyAxis+1)
+	refRange := vxAxis - hxAxis
+	return f.autoFilter(sheet, ref, refRange, hxAxis, formatSet)
+}
+
+// autoFilter provides a function to extract the tokens from the filter
+// expression. The tokens are mainly non-whitespace groups.
+func (f *File) autoFilter(sheet, ref string, refRange, hxAxis int, formatSet *formatAutoFilter) error {
+	xlsx := f.workSheetReader(sheet)
+	if xlsx.SheetPr != nil {
+		xlsx.SheetPr.FilterMode = true
+	}
+	xlsx.SheetPr = &xlsxSheetPr{FilterMode: true}
+	filter := &xlsxAutoFilter{
+		Ref: ref,
+	}
+	xlsx.AutoFilter = filter
+	if formatSet.Column == "" || formatSet.Expression == "" {
+		return nil
+	}
+	col := TitleToNumber(formatSet.Column)
+	offset := col - hxAxis
+	if offset < 0 || offset > refRange {
+		return fmt.Errorf("Incorrect index of column '%s'", formatSet.Column)
+	}
+	filter.FilterColumn = &xlsxFilterColumn{
+		ColID: offset,
+	}
+	re := regexp.MustCompile(`"(?:[^"]|"")*"|\S+`)
+	token := re.FindAllString(formatSet.Expression, -1)
+	if len(token) != 3 && len(token) != 7 {
+		return fmt.Errorf("Incorrect number of tokens in criteria '%s'", formatSet.Expression)
+	}
+	expressions, tokens, err := f.parseFilterExpression(formatSet.Expression, token)
+	if err != nil {
+		return err
+	}
+	f.writeAutoFilter(filter, expressions, tokens)
+	xlsx.AutoFilter = filter
+	return nil
+}
+
+// writeAutoFilter provides a function to check for single or double custom
+// filters as default filters and handle them accordingly.
+func (f *File) writeAutoFilter(filter *xlsxAutoFilter, exp []int, tokens []string) {
+	if len(exp) == 1 && exp[0] == 2 {
+		// Single equality.
+		filters := []*xlsxFilter{}
+		filters = append(filters, &xlsxFilter{Val: tokens[0]})
+		filter.FilterColumn.Filters = &xlsxFilters{Filter: filters}
+	} else if len(exp) == 3 && exp[0] == 2 && exp[1] == 1 && exp[2] == 2 {
+		// Double equality with "or" operator.
+		filters := []*xlsxFilter{}
+		for _, v := range tokens {
+			filters = append(filters, &xlsxFilter{Val: v})
+		}
+		filter.FilterColumn.Filters = &xlsxFilters{Filter: filters}
+	} else {
+		// Non default custom filter.
+		expRel := map[int]int{0: 0, 1: 2}
+		andRel := map[int]bool{0: true, 1: false}
+		for k, v := range tokens {
+			f.writeCustomFilter(filter, exp[expRel[k]], v)
+			if k == 1 {
+				filter.FilterColumn.CustomFilters.And = andRel[exp[k]]
+			}
+		}
+	}
+}
+
+// writeCustomFilter provides a function to write the <customFilter> element.
+func (f *File) writeCustomFilter(filter *xlsxAutoFilter, operator int, val string) {
+	operators := map[int]string{
+		1:  "lessThan",
+		2:  "equal",
+		3:  "lessThanOrEqual",
+		4:  "greaterThan",
+		5:  "notEqual",
+		6:  "greaterThanOrEqual",
+		22: "equal",
+	}
+	customFilter := xlsxCustomFilter{
+		Operator: operators[operator],
+		Val:      val,
+	}
+	if filter.FilterColumn.CustomFilters != nil {
+		filter.FilterColumn.CustomFilters.CustomFilter = append(filter.FilterColumn.CustomFilters.CustomFilter, &customFilter)
+	} else {
+		customFilters := []*xlsxCustomFilter{}
+		customFilters = append(customFilters, &customFilter)
+		filter.FilterColumn.CustomFilters = &xlsxCustomFilters{CustomFilter: customFilters}
+	}
+}
+
+// parseFilterExpression provides a function to converts the tokens of a
+// possibly conditional expression into 1 or 2 sub expressions for further
+// parsing.
+//
+// Examples:
+//
+//    ('x', '==', 2000) -> exp1
+//    ('x', '>',  2000, 'and', 'x', '<', 5000) -> exp1 and exp2
+//
+func (f *File) parseFilterExpression(expression string, tokens []string) ([]int, []string, error) {
+	expressions := []int{}
+	t := []string{}
+	if len(tokens) == 7 {
+		// The number of tokens will be either 3 (for 1 expression) or 7 (for 2
+		// expressions).
+		conditional := 0
+		c := tokens[3]
+		re, _ := regexp.Match(`(or|\|\|)`, []byte(c))
+		if re {
+			conditional = 1
+		}
+		expression1, token1, err := f.parseFilterTokens(expression, tokens[0:3])
+		if err != nil {
+			return expressions, t, err
+		}
+		expression2, token2, err := f.parseFilterTokens(expression, tokens[4:7])
+		if err != nil {
+			return expressions, t, err
+		}
+		expressions = []int{expression1[0], conditional, expression2[0]}
+		t = []string{token1, token2}
+	} else {
+		exp, token, err := f.parseFilterTokens(expression, tokens)
+		if err != nil {
+			return expressions, t, err
+		}
+		expressions = exp
+		t = []string{token}
+	}
+	return expressions, t, nil
+}
+
+// parseFilterTokens provides a function to parse the 3 tokens of a filter
+// expression and return the operator and token.
+func (f *File) parseFilterTokens(expression string, tokens []string) ([]int, string, error) {
+	operators := map[string]int{
+		"==": 2,
+		"=":  2,
+		"=~": 2,
+		"eq": 2,
+		"!=": 5,
+		"!~": 5,
+		"ne": 5,
+		"<>": 5,
+		"<":  1,
+		"<=": 3,
+		">":  4,
+		">=": 6,
+	}
+	operator, ok := operators[strings.ToLower(tokens[1])]
+	if !ok {
+		// Convert the operator from a number to a descriptive string.
+		return []int{}, "", fmt.Errorf("Unknown operator: %s", tokens[1])
+	}
+	token := tokens[2]
+	// Special handling for Blanks/NonBlanks.
+	re, _ := regexp.Match("blanks|nonblanks", []byte(strings.ToLower(token)))
+	if re {
+		// Only allow Equals or NotEqual in this context.
+		if operator != 2 && operator != 5 {
+			return []int{operator}, token, fmt.Errorf("The operator '%s' in expression '%s' is not valid in relation to Blanks/NonBlanks'", tokens[1], expression)
+		}
+		token = strings.ToLower(token)
+		// The operator should always be 2 (=) to flag a "simple" equality in
+		// the binary record. Therefore we convert <> to =.
+		if token == "blanks" {
+			if operator == 5 {
+				token = " "
+			}
+		} else {
+			if operator == 5 {
+				operator = 2
+				token = "blanks"
+			} else {
+				operator = 5
+				token = " "
+			}
+		}
+	}
+	// if the string token contains an Excel match character then change the
+	// operator type to indicate a non "simple" equality.
+	re, _ = regexp.Match("[*?]", []byte(token))
+	if operator == 2 && re {
+		operator = 22
+	}
+	return []int{operator}, token, nil
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/vmlDrawing.go

@@ -0,0 +1,135 @@
+package excelize
+
+import "encoding/xml"
+
+// vmlDrawing directly maps the root element in the file
+// xl/drawings/vmlDrawing%d.vml.
+type vmlDrawing struct {
+	XMLName     xml.Name         `xml:"xml"`
+	XMLNSv      string           `xml:"xmlns:v,attr"`
+	XMLNSo      string           `xml:"xmlns:o,attr"`
+	XMLNSx      string           `xml:"xmlns:x,attr"`
+	XMLNSmv     string           `xml:"xmlns:mv,attr"`
+	Shapelayout *xlsxShapelayout `xml:"o:shapelayout"`
+	Shapetype   *xlsxShapetype   `xml:"v:shapetype"`
+	Shape       []xlsxShape      `xml:"v:shape"`
+}
+
+// xlsxShapelayout directly maps the shapelayout element. This element contains
+// child elements that store information used in the editing and layout of
+// shapes.
+type xlsxShapelayout struct {
+	Ext   string     `xml:"v:ext,attr"`
+	IDmap *xlsxIDmap `xml:"o:idmap"`
+}
+
+// xlsxIDmap directly maps the idmap element.
+type xlsxIDmap struct {
+	Ext  string `xml:"v:ext,attr"`
+	Data int    `xml:"data,attr"`
+}
+
+// xlsxShape directly maps the shape element.
+type xlsxShape struct {
+	XMLName     xml.Name `xml:"v:shape"`
+	ID          string   `xml:"id,attr"`
+	Type        string   `xml:"type,attr"`
+	Style       string   `xml:"style,attr"`
+	Fillcolor   string   `xml:"fillcolor,attr"`
+	Insetmode   string   `xml:"urn:schemas-microsoft-com:office:office insetmode,attr,omitempty"`
+	Strokecolor string   `xml:"strokecolor,attr,omitempty"`
+	Val         string   `xml:",innerxml"`
+}
+
+// xlsxShapetype directly maps the shapetype element.
+type xlsxShapetype struct {
+	ID        string      `xml:"id,attr"`
+	Coordsize string      `xml:"coordsize,attr"`
+	Spt       int         `xml:"o:spt,attr"`
+	Path      string      `xml:"path,attr"`
+	Stroke    *xlsxStroke `xml:"v:stroke"`
+	VPath     *vPath      `xml:"v:path"`
+}
+
+// xlsxStroke directly maps the stroke element.
+type xlsxStroke struct {
+	Joinstyle string `xml:"joinstyle,attr"`
+}
+
+// vPath directly maps the v:path element.
+type vPath struct {
+	Gradientshapeok string `xml:"gradientshapeok,attr,omitempty"`
+	Connecttype     string `xml:"o:connecttype,attr"`
+}
+
+// vFill directly maps the v:fill element. This element must be defined within a
+// Shape element.
+type vFill struct {
+	Angle  int    `xml:"angle,attr,omitempty"`
+	Color2 string `xml:"color2,attr"`
+	Type   string `xml:"type,attr,omitempty"`
+	Fill   *oFill `xml:"o:fill"`
+}
+
+// oFill directly maps the o:fill element.
+type oFill struct {
+	Ext  string `xml:"v:ext,attr"`
+	Type string `xml:"type,attr,omitempty"`
+}
+
+// vShadow directly maps the v:shadow element. This element must be defined
+// within a Shape element. In addition, the On attribute must be set to True.
+type vShadow struct {
+	On       string `xml:"on,attr"`
+	Color    string `xml:"color,attr,omitempty"`
+	Obscured string `xml:"obscured,attr"`
+}
+
+// vTextbox directly maps the v:textbox element. This element must be defined
+// within a Shape element.
+type vTextbox struct {
+	Style string   `xml:"style,attr"`
+	Div   *xlsxDiv `xml:"div"`
+}
+
+// xlsxDiv directly maps the div element.
+type xlsxDiv struct {
+	Style string `xml:"style,attr"`
+}
+
+// xClientData (Attached Object Data) directly maps the x:ClientData element.
+// This element specifies data associated with objects attached to a
+// spreadsheet. While this element might contain any of the child elements
+// below, only certain combinations are meaningful. The ObjectType attribute
+// determines the kind of object the element represents and which subset of
+// child elements is appropriate. Relevant groups are identified for each child
+// element.
+type xClientData struct {
+	ObjectType    string `xml:"ObjectType,attr"`
+	MoveWithCells string `xml:"x:MoveWithCells,omitempty"`
+	SizeWithCells string `xml:"x:SizeWithCells,omitempty"`
+	Anchor        string `xml:"x:Anchor"`
+	AutoFill      string `xml:"x:AutoFill"`
+	Row           int    `xml:"x:Row"`
+	Column        int    `xml:"x:Column"`
+}
+
+// decodeVmlDrawing defines the structure used to parse the file
+// xl/drawings/vmlDrawing%d.vml.
+type decodeVmlDrawing struct {
+	Shape []decodeShape `xml:"urn:schemas-microsoft-com:vml shape"`
+}
+
+// decodeShape defines the structure used to parse the particular shape element.
+type decodeShape struct {
+	Val string `xml:",innerxml"`
+}
+
+// encodeShape defines the structure used to re-serialization shape element.
+type encodeShape struct {
+	Fill       *vFill       `xml:"v:fill"`
+	Shadow     *vShadow     `xml:"v:shadow"`
+	Path       *vPath       `xml:"v:path"`
+	Textbox    *vTextbox    `xml:"v:textbox"`
+	ClientData *xClientData `xml:"x:ClientData"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlChart.go

@@ -0,0 +1,612 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxChartSpace directly maps the c:chartSpace element. The chart namespace in
+// DrawingML is for representing visualizations of numeric data with column
+// charts, pie charts, scatter charts, or other types of charts.
+type xlsxChartSpace struct {
+	XMLName        xml.Name        `xml:"c:chartSpace"`
+	XMLNSc         string          `xml:"xmlns:c,attr"`
+	XMLNSa         string          `xml:"xmlns:a,attr"`
+	XMLNSr         string          `xml:"xmlns:r,attr"`
+	XMLNSc16r2     string          `xml:"xmlns:c16r2,attr"`
+	Date1904       *attrValBool    `xml:"c:date1904"`
+	Lang           *attrValString  `xml:"c:lang"`
+	RoundedCorners *attrValBool    `xml:"c:roundedCorners"`
+	Chart          cChart          `xml:"c:chart"`
+	SpPr           *cSpPr          `xml:"c:spPr"`
+	TxPr           *cTxPr          `xml:"c:txPr"`
+	PrintSettings  *cPrintSettings `xml:"c:printSettings"`
+}
+
+// cThicknessSpPr directly maps the element that specifies the thickness of the
+// walls or floor as a percentage of the largest dimension of the plot volume
+// and SpPr element.
+type cThicknessSpPr struct {
+	Thickness *attrValInt `xml:"c:thickness"`
+	SpPr      *cSpPr      `xml:"c:spPr"`
+}
+
+// cChart (Chart) directly maps the c:chart element. This element specifies a
+// title.
+type cChart struct {
+	Title            *cTitle            `xml:"c:title"`
+	AutoTitleDeleted *cAutoTitleDeleted `xml:"c:autoTitleDeleted"`
+	View3D           *cView3D           `xml:"c:view3D"`
+	Floor            *cThicknessSpPr    `xml:"c:floor"`
+	SideWall         *cThicknessSpPr    `xml:"c:sideWall"`
+	BackWall         *cThicknessSpPr    `xml:"c:backWall"`
+	PlotArea         *cPlotArea         `xml:"c:plotArea"`
+	Legend           *cLegend           `xml:"c:legend"`
+	PlotVisOnly      *attrValBool       `xml:"c:plotVisOnly"`
+	DispBlanksAs     *attrValString     `xml:"c:dispBlanksAs"`
+	ShowDLblsOverMax *attrValBool       `xml:"c:showDLblsOverMax"`
+}
+
+// cTitle (Title) directly maps the c:title element. This element specifies a
+// title.
+type cTitle struct {
+	Tx      cTx         `xml:"c:tx,omitempty"`
+	Layout  string      `xml:"c:layout,omitempty"`
+	Overlay attrValBool `xml:"c:overlay,omitempty"`
+	SpPr    cSpPr       `xml:"c:spPr,omitempty"`
+	TxPr    cTxPr       `xml:"c:txPr,omitempty"`
+}
+
+// cTx (Chart Text) directly maps the c:tx element. This element specifies text
+// to use on a chart, including rich text formatting.
+type cTx struct {
+	StrRef *cStrRef `xml:"c:strRef"`
+	Rich   *cRich   `xml:"c:rich,omitempty"`
+}
+
+// cRich (Rich Text) directly maps the c:rich element. This element contains a
+// string with rich text formatting.
+type cRich struct {
+	BodyPr   aBodyPr `xml:"a:bodyPr,omitempty"`
+	LstStyle string  `xml:"a:lstStyle,omitempty"`
+	P        aP      `xml:"a:p"`
+}
+
+// aBodyPr (Body Properties) directly maps the a:bodyPr element. This element
+// defines the body properties for the text body within a shape.
+type aBodyPr struct {
+	Anchor           string  `xml:"anchor,attr,omitempty"`
+	AnchorCtr        bool    `xml:"anchorCtr,attr"`
+	Rot              int     `xml:"rot,attr"`
+	BIns             float64 `xml:"bIns,attr,omitempty"`
+	CompatLnSpc      bool    `xml:"compatLnSpc,attr,omitempty"`
+	ForceAA          bool    `xml:"forceAA,attr,omitempty"`
+	FromWordArt      bool    `xml:"fromWordArt,attr,omitempty"`
+	HorzOverflow     string  `xml:"horzOverflow,attr,omitempty"`
+	LIns             float64 `xml:"lIns,attr,omitempty"`
+	NumCol           int     `xml:"numCol,attr,omitempty"`
+	RIns             float64 `xml:"rIns,attr,omitempty"`
+	RtlCol           bool    `xml:"rtlCol,attr,omitempty"`
+	SpcCol           int     `xml:"spcCol,attr,omitempty"`
+	SpcFirstLastPara bool    `xml:"spcFirstLastPara,attr"`
+	TIns             float64 `xml:"tIns,attr,omitempty"`
+	Upright          bool    `xml:"upright,attr,omitempty"`
+	Vert             string  `xml:"vert,attr,omitempty"`
+	VertOverflow     string  `xml:"vertOverflow,attr,omitempty"`
+	Wrap             string  `xml:"wrap,attr,omitempty"`
+}
+
+// aP (Paragraph) directly maps the a:p element. This element specifies a
+// paragraph of content in the document.
+type aP struct {
+	PPr        *aPPr        `xml:"a:pPr"`
+	R          *aR          `xml:"a:r"`
+	EndParaRPr *aEndParaRPr `xml:"a:endParaRPr"`
+}
+
+// aPPr (Paragraph Properties) directly maps the a:pPr element. This element
+// specifies a set of paragraph properties which shall be applied to the
+// contents of the parent paragraph after all style/numbering/table properties
+// have been applied to the text. These properties are defined as direct
+// formatting, since they are directly applied to the paragraph and supersede
+// any formatting from styles.
+type aPPr struct {
+	DefRPr aRPr `xml:"a:defRPr"`
+}
+
+// aSolidFill (Solid Fill) directly maps the solidFill element. This element
+// specifies a solid color fill. The shape is filled entirely with the specified
+// color.
+type aSolidFill struct {
+	SchemeClr *aSchemeClr    `xml:"a:schemeClr"`
+	SrgbClr   *attrValString `xml:"a:srgbClr"`
+}
+
+// aSchemeClr (Scheme Color) directly maps the a:schemeClr element. This
+// element specifies a color bound to a user's theme. As with all elements which
+// define a color, it is possible to apply a list of color transforms to the
+// base color defined.
+type aSchemeClr struct {
+	Val    string      `xml:"val,attr,omitempty"`
+	LumMod *attrValInt `xml:"a:lumMod"`
+	LumOff *attrValInt `xml:"a:lumOff"`
+}
+
+// attrValInt directly maps the val element with integer data type as an
+// attribute。
+type attrValInt struct {
+	Val int `xml:"val,attr"`
+}
+
+// attrValFloat directly maps the val element with float64 data type as an
+// attribute。
+type attrValFloat struct {
+	Val float64 `xml:"val,attr"`
+}
+
+// attrValBool directly maps the val element with boolean data type as an
+// attribute。
+type attrValBool struct {
+	Val bool `xml:"val,attr"`
+}
+
+// attrValString directly maps the val element with string data type as an
+// attribute。
+type attrValString struct {
+	Val string `xml:"val,attr"`
+}
+
+// aCs directly maps the a:cs element.
+type aCs struct {
+	Typeface string `xml:"typeface,attr"`
+}
+
+// aEa directly maps the a:ea element.
+type aEa struct {
+	Typeface string `xml:"typeface,attr"`
+}
+
+// aLatin (Latin Font) directly maps the a:latin element. This element
+// specifies that a Latin font be used for a specific run of text. This font is
+// specified with a typeface attribute much like the others but is specifically
+// classified as a Latin font.
+type aLatin struct {
+	Typeface string `xml:"typeface,attr"`
+}
+
+// aR directly maps the a:r element.
+type aR struct {
+	RPr aRPr   `xml:"a:rPr,omitempty"`
+	T   string `xml:"a:t,omitempty"`
+}
+
+// aRPr (Run Properties) directly maps the c:rPr element. This element
+// specifies a set of run properties which shall be applied to the contents of
+// the parent run after all style formatting has been applied to the text. These
+// properties are defined as direct formatting, since they are directly applied
+// to the run and supersede any formatting from styles.
+type aRPr struct {
+	AltLang    string      `xml:"altLang,attr,omitempty"`
+	B          bool        `xml:"b,attr"`
+	Baseline   int         `xml:"baseline,attr"`
+	Bmk        string      `xml:"bmk,attr,omitempty"`
+	Cap        string      `xml:"cap,attr,omitempty"`
+	Dirty      bool        `xml:"dirty,attr,omitempty"`
+	Err        bool        `xml:"err,attr,omitempty"`
+	I          bool        `xml:"i,attr"`
+	Kern       int         `xml:"kern,attr"`
+	Kumimoji   bool        `xml:"kumimoji,attr,omitempty"`
+	Lang       string      `xml:"lang,attr,omitempty"`
+	NoProof    bool        `xml:"noProof,attr,omitempty"`
+	NormalizeH bool        `xml:"normalizeH,attr,omitempty"`
+	SmtClean   bool        `xml:"smtClean,attr,omitempty"`
+	SmtID      uint64      `xml:"smtId,attr,omitempty"`
+	Spc        int         `xml:"spc,attr"`
+	Strike     string      `xml:"strike,attr,omitempty"`
+	Sz         int         `xml:"sz,attr,omitempty"`
+	U          string      `xml:"u,attr,omitempty"`
+	SolidFill  *aSolidFill `xml:"a:solidFill"`
+	Latin      *aLatin     `xml:"a:latin"`
+	Ea         *aEa        `xml:"a:ea"`
+	Cs         *aCs        `xml:"a:cs"`
+}
+
+// cSpPr (Shape Properties) directly maps the c:spPr element. This element
+// specifies the visual shape properties that can be applied to a shape. These
+// properties include the shape fill, outline, geometry, effects, and 3D
+// orientation.
+type cSpPr struct {
+	NoFill    *string     `xml:"a:noFill"`
+	SolidFill *aSolidFill `xml:"a:solidFill"`
+	Ln        *aLn        `xml:"a:ln"`
+	Sp3D      *aSp3D      `xml:"a:sp3d"`
+	EffectLst *string     `xml:"a:effectLst"`
+}
+
+// aSp3D (3-D Shape Properties) directly maps the a:sp3d element. This element
+// defines the 3D properties associated with a particular shape in DrawingML.
+// The 3D properties which can be applied to a shape are top and bottom bevels,
+// a contour and an extrusion.
+type aSp3D struct {
+	ContourW   int          `xml:"contourW,attr"`
+	ContourClr *aContourClr `xml:"a:contourClr"`
+}
+
+// aContourClr (Contour Color) directly maps the a:contourClr element. This
+// element defines the color for the contour on a shape. The contour of a shape
+// is a solid filled line which surrounds the outer edges of the shape.
+type aContourClr struct {
+	SchemeClr *aSchemeClr `xml:"a:schemeClr"`
+}
+
+// aLn (Outline) directly maps the a:ln element. This element specifies an
+// outline style that can be applied to a number of different objects such as
+// shapes and text. The line allows for the specifying of many different types
+// of outlines including even line dashes and bevels.
+type aLn struct {
+	Algn      string      `xml:"algn,attr,omitempty"`
+	Cap       string      `xml:"cap,attr,omitempty"`
+	Cmpd      string      `xml:"cmpd,attr,omitempty"`
+	W         int         `xml:"w,attr,omitempty" `
+	NoFill    string      `xml:"a:noFill,omitempty"`
+	Round     string      `xml:"a:round,omitempty"`
+	SolidFill *aSolidFill `xml:"a:solidFill"`
+}
+
+// cTxPr (Text Properties) directly maps the c:txPr element. This element
+// specifies text formatting. The lstStyle element is not supported.
+type cTxPr struct {
+	BodyPr   aBodyPr `xml:"a:bodyPr,omitempty"`
+	LstStyle string  `xml:"a:lstStyle,omitempty"`
+	P        aP      `xml:"a:p,omitempty"`
+}
+
+// aEndParaRPr (End Paragraph Run Properties) directly maps the a:endParaRPr
+// element. This element specifies the text run properties that are to be used
+// if another run is inserted after the last run specified. This effectively
+// saves the run property state so that it can be applied when the user enters
+// additional text. If this element is omitted, then the application can
+// determine which default properties to apply. It is recommended that this
+// element be specified at the end of the list of text runs within the paragraph
+// so that an orderly list is maintained.
+type aEndParaRPr struct {
+	Lang    string `xml:"lang,attr"`
+	AltLang string `xml:"altLang,attr,omitempty"`
+	Sz      int    `xml:"sz,attr,omitempty"`
+}
+
+// cAutoTitleDeleted (Auto Title Is Deleted) directly maps the
+// c:autoTitleDeleted element. This element specifies the title shall not be
+// shown for this chart.
+type cAutoTitleDeleted struct {
+	Val bool `xml:"val,attr"`
+}
+
+// cView3D (View In 3D) directly maps the c:view3D element. This element
+// specifies the 3-D view of the chart.
+type cView3D struct {
+	RotX         *attrValInt `xml:"c:rotX"`
+	RotY         *attrValInt `xml:"c:rotY"`
+	DepthPercent *attrValInt `xml:"c:depthPercent"`
+	RAngAx       *attrValInt `xml:"c:rAngAx"`
+}
+
+// cPlotArea directly maps the c:plotArea element. This element specifies the
+// plot area of the chart.
+type cPlotArea struct {
+	Layout        *string  `xml:"c:layout"`
+	BarChart      *cCharts `xml:"c:barChart"`
+	Bar3DChart    *cCharts `xml:"c:bar3DChart"`
+	DoughnutChart *cCharts `xml:"c:doughnutChart"`
+	LineChart     *cCharts `xml:"c:lineChart"`
+	PieChart      *cCharts `xml:"c:pieChart"`
+	Pie3DChart    *cCharts `xml:"c:pie3DChart"`
+	RadarChart    *cCharts `xml:"c:radarChart"`
+	ScatterChart  *cCharts `xml:"c:scatterChart"`
+	CatAx         []*cAxs  `xml:"c:catAx"`
+	ValAx         []*cAxs  `xml:"c:valAx"`
+	SpPr          *cSpPr   `xml:"c:spPr"`
+}
+
+// cCharts specifies the common element of the chart.
+type cCharts struct {
+	BarDir       *attrValString `xml:"c:barDir"`
+	Grouping     *attrValString `xml:"c:grouping"`
+	RadarStyle   *attrValString `xml:"c:radarStyle"`
+	ScatterStyle *attrValString `xml:"c:scatterStyle"`
+	VaryColors   *attrValBool   `xml:"c:varyColors"`
+	Ser          *[]cSer        `xml:"c:ser"`
+	DLbls        *cDLbls        `xml:"c:dLbls"`
+	HoleSize     *attrValInt    `xml:"c:holeSize"`
+	Smooth       *attrValBool   `xml:"c:smooth"`
+	Overlap      *attrValInt    `xml:"c:overlap"`
+	AxID         []*attrValInt  `xml:"c:axId"`
+}
+
+// cAxs directly maps the c:catAx and c:valAx element.
+type cAxs struct {
+	AxID          *attrValInt    `xml:"c:axId"`
+	Scaling       *cScaling      `xml:"c:scaling"`
+	Delete        *attrValBool   `xml:"c:delete"`
+	AxPos         *attrValString `xml:"c:axPos"`
+	NumFmt        *cNumFmt       `xml:"c:numFmt"`
+	MajorTickMark *attrValString `xml:"c:majorTickMark"`
+	MinorTickMark *attrValString `xml:"c:minorTickMark"`
+	TickLblPos    *attrValString `xml:"c:tickLblPos"`
+	SpPr          *cSpPr         `xml:"c:spPr"`
+	TxPr          *cTxPr         `xml:"c:txPr"`
+	CrossAx       *attrValInt    `xml:"c:crossAx"`
+	Crosses       *attrValString `xml:"c:crosses"`
+	CrossBetween  *attrValString `xml:"c:crossBetween"`
+	Auto          *attrValBool   `xml:"c:auto"`
+	LblAlgn       *attrValString `xml:"c:lblAlgn"`
+	LblOffset     *attrValInt    `xml:"c:lblOffset"`
+	NoMultiLvlLbl *attrValBool   `xml:"c:noMultiLvlLbl"`
+}
+
+// cScaling directly maps the c:scaling element. This element contains
+// additional axis settings.
+type cScaling struct {
+	Orientation *attrValString `xml:"c:orientation"`
+	Max         *attrValFloat  `xml:"c:max"`
+	Min         *attrValFloat  `xml:"c:min"`
+}
+
+// cNumFmt (Numbering Format) directly maps the c:numFmt element. This element
+// specifies number formatting for the parent element.
+type cNumFmt struct {
+	FormatCode   string `xml:"formatCode,attr"`
+	SourceLinked bool   `xml:"sourceLinked,attr"`
+}
+
+// cSer directly maps the c:ser element. This element specifies a series on a
+// chart.
+type cSer struct {
+	IDx              *attrValInt  `xml:"c:idx"`
+	Order            *attrValInt  `xml:"c:order"`
+	Tx               *cTx         `xml:"c:tx"`
+	SpPr             *cSpPr       `xml:"c:spPr"`
+	DPt              []*cDPt      `xml:"c:dPt"`
+	DLbls            *cDLbls      `xml:"c:dLbls"`
+	Marker           *cMarker     `xml:"c:marker"`
+	InvertIfNegative *attrValBool `xml:"c:invertIfNegative"`
+	Cat              *cCat        `xml:"c:cat"`
+	Val              *cVal        `xml:"c:val"`
+	XVal             *cCat        `xml:"c:xVal"`
+	YVal             *cVal        `xml:"c:yVal"`
+	Smooth           *attrValBool `xml:"c:smooth"`
+}
+
+// cMarker (Marker) directly maps the c:marker element. This element specifies a
+// data marker.
+type cMarker struct {
+	Symbol *attrValString `xml:"c:symbol"`
+	Size   *attrValInt    `xml:"c:size"`
+	SpPr   *cSpPr         `xml:"c:spPr"`
+}
+
+// cDPt (Data Point) directly maps the c:dPt element. This element specifies a
+// single data point.
+type cDPt struct {
+	IDx      *attrValInt  `xml:"c:idx"`
+	Bubble3D *attrValBool `xml:"c:bubble3D"`
+	SpPr     *cSpPr       `xml:"c:spPr"`
+}
+
+// cCat (Category Axis Data) directly maps the c:cat element. This element
+// specifies the data used for the category axis.
+type cCat struct {
+	StrRef *cStrRef `xml:"c:strRef"`
+}
+
+// cStrRef (String Reference) directly maps the c:strRef element. This element
+// specifies a reference to data for a single data label or title with a cache
+// of the last values used.
+type cStrRef struct {
+	F        string     `xml:"c:f"`
+	StrCache *cStrCache `xml:"c:strCache"`
+}
+
+// cStrCache (String Cache) directly maps the c:strCache element. This element
+// specifies the last string data used for a chart.
+type cStrCache struct {
+	Pt      []*cPt      `xml:"c:pt"`
+	PtCount *attrValInt `xml:"c:ptCount"`
+}
+
+// cPt directly maps the c:pt element. This element specifies data for a
+// particular data point.
+type cPt struct {
+	IDx int     `xml:"idx,attr"`
+	V   *string `xml:"c:v"`
+}
+
+// cVal directly maps the c:val element. This element specifies the data values
+// which shall be used to define the location of data markers on a chart.
+type cVal struct {
+	NumRef *cNumRef `xml:"c:numRef"`
+}
+
+// cNumRef directly maps the c:numRef element. This element specifies a
+// reference to numeric data with a cache of the last values used.
+type cNumRef struct {
+	F        string     `xml:"c:f"`
+	NumCache *cNumCache `xml:"c:numCache"`
+}
+
+// cNumCache directly maps the c:numCache element. This element specifies the
+// last data shown on the chart for a series.
+type cNumCache struct {
+	FormatCode string      `xml:"c:formatCode"`
+	Pt         []*cPt      `xml:"c:pt"`
+	PtCount    *attrValInt `xml:"c:ptCount"`
+}
+
+// cDLbls (Data Lables) directly maps the c:dLbls element. This element serves
+// as a root element that specifies the settings for the data labels for an
+// entire series or the entire chart. It contains child elements that specify
+// the specific formatting and positioning settings.
+type cDLbls struct {
+	ShowLegendKey   *attrValBool `xml:"c:showLegendKey"`
+	ShowVal         *attrValBool `xml:"c:showVal"`
+	ShowCatName     *attrValBool `xml:"c:showCatName"`
+	ShowSerName     *attrValBool `xml:"c:showSerName"`
+	ShowPercent     *attrValBool `xml:"c:showPercent"`
+	ShowBubbleSize  *attrValBool `xml:"c:showBubbleSize"`
+	ShowLeaderLines *attrValBool `xml:"c:showLeaderLines"`
+}
+
+// cLegend (Legend) directly maps the c:legend element. This element specifies
+// the legend.
+type cLegend struct {
+	Layout    *string        `xml:"c:layout"`
+	LegendPos *attrValString `xml:"c:legendPos"`
+	Overlay   *attrValBool   `xml:"c:overlay"`
+	SpPr      *cSpPr         `xml:"c:spPr"`
+	TxPr      *cTxPr         `xml:"c:txPr"`
+}
+
+// cPrintSettings directly maps the c:printSettings element. This element
+// specifies the print settings for the chart.
+type cPrintSettings struct {
+	HeaderFooter *string       `xml:"c:headerFooter"`
+	PageMargins  *cPageMargins `xml:"c:pageMargins"`
+	PageSetup    *string       `xml:"c:pageSetup"`
+}
+
+// cPageMargins directly maps the c:pageMargins element. This element specifies
+// the page margins for a chart.
+type cPageMargins struct {
+	B      float64 `xml:"b,attr"`
+	Footer float64 `xml:"footer,attr"`
+	Header float64 `xml:"header,attr"`
+	L      float64 `xml:"l,attr"`
+	R      float64 `xml:"r,attr"`
+	T      float64 `xml:"t,attr"`
+}
+
+// formatChartAxis directly maps the format settings of the chart axis.
+type formatChartAxis struct {
+	Crossing            string  `json:"crossing"`
+	MajorTickMark       string  `json:"major_tick_mark"`
+	MinorTickMark       string  `json:"minor_tick_mark"`
+	MinorUnitType       string  `json:"minor_unit_type"`
+	MajorUnit           int     `json:"major_unit"`
+	MajorUnitType       string  `json:"major_unit_type"`
+	DisplayUnits        string  `json:"display_units"`
+	DisplayUnitsVisible bool    `json:"display_units_visible"`
+	DateAxis            bool    `json:"date_axis"`
+	ReverseOrder        bool    `json:"reverse_order"`
+	Maximum             float64 `json:"maximum"`
+	Minimum             float64 `json:"minimum"`
+	NumFormat           string  `json:"num_format"`
+	NumFont             struct {
+		Color     string `json:"color"`
+		Bold      bool   `json:"bold"`
+		Italic    bool   `json:"italic"`
+		Underline bool   `json:"underline"`
+	} `json:"num_font"`
+	NameLayout formatLayout `json:"name_layout"`
+}
+
+type formatChartDimension struct {
+	Width  int `json:"width"`
+	Height int `json:"height"`
+}
+
+// formatChart directly maps the format settings of the chart.
+type formatChart struct {
+	Type      string               `json:"type"`
+	Series    []formatChartSeries  `json:"series"`
+	Format    formatPicture        `json:"format"`
+	Dimension formatChartDimension `json:"dimension"`
+	Legend    formatChartLegend    `json:"legend"`
+	Title     formatChartTitle     `json:"title"`
+	XAxis     formatChartAxis      `json:"x_axis"`
+	YAxis     formatChartAxis      `json:"y_axis"`
+	Chartarea struct {
+		Border struct {
+			None bool `json:"none"`
+		} `json:"border"`
+		Fill struct {
+			Color string `json:"color"`
+		} `json:"fill"`
+		Pattern struct {
+			Pattern string `json:"pattern"`
+			FgColor string `json:"fg_color"`
+			BgColor string `json:"bg_color"`
+		} `json:"pattern"`
+	} `json:"chartarea"`
+	Plotarea struct {
+		ShowBubbleSize  bool `json:"show_bubble_size"`
+		ShowCatName     bool `json:"show_cat_name"`
+		ShowLeaderLines bool `json:"show_leader_lines"`
+		ShowPercent     bool `json:"show_percent"`
+		ShowSerName     bool `json:"show_series_name"`
+		ShowVal         bool `json:"show_val"`
+		Gradient        struct {
+			Colors []string `json:"colors"`
+		} `json:"gradient"`
+		Border struct {
+			Color    string `json:"color"`
+			Width    int    `json:"width"`
+			DashType string `json:"dash_type"`
+		} `json:"border"`
+		Fill struct {
+			Color string `json:"color"`
+		} `json:"fill"`
+		Layout formatLayout `json:"layout"`
+	} `json:"plotarea"`
+	ShowBlanksAs   string `json:"show_blanks_as"`
+	ShowHiddenData bool   `json:"show_hidden_data"`
+	SetRotation    int    `json:"set_rotation"`
+	SetHoleSize    int    `json:"set_hole_size"`
+}
+
+// formatChartLegend directly maps the format settings of the chart legend.
+type formatChartLegend struct {
+	None            bool         `json:"none"`
+	DeleteSeries    []int        `json:"delete_series"`
+	Font            formatFont   `json:"font"`
+	Layout          formatLayout `json:"layout"`
+	Position        string       `json:"position"`
+	ShowLegendEntry bool         `json:"show_legend_entry"`
+	ShowLegendKey   bool         `json:"show_legend_key"`
+}
+
+// formatChartSeries directly maps the format settings of the chart series.
+type formatChartSeries struct {
+	Name       string `json:"name"`
+	Categories string `json:"categories"`
+	Values     string `json:"values"`
+	Line       struct {
+		None  bool   `json:"none"`
+		Color string `json:"color"`
+	} `json:"line"`
+	Marker struct {
+		Type   string  `json:"type"`
+		Size   int     `json:"size,"`
+		Width  float64 `json:"width"`
+		Border struct {
+			Color string `json:"color"`
+			None  bool   `json:"none"`
+		} `json:"border"`
+		Fill struct {
+			Color string `json:"color"`
+			None  bool   `json:"none"`
+		} `json:"fill"`
+	} `json:"marker"`
+}
+
+// formatChartTitle directly maps the format settings of the chart title.
+type formatChartTitle struct {
+	None    bool         `json:"none"`
+	Name    string       `json:"name"`
+	Overlay bool         `json:"overlay"`
+	Layout  formatLayout `json:"layout"`
+}
+
+// formatLayout directly maps the format settings of the element layout.
+type formatLayout struct {
+	X      float64 `json:"x"`
+	Y      float64 `json:"y"`
+	Width  float64 `json:"width"`
+	Height float64 `json:"height"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlComments.go

@@ -0,0 +1,55 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxComments directly maps the comments element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main. A comment is a
+// rich text note that is attached to and associated with a cell, separate from
+// other cell content. Comment content is stored separate from the cell, and is
+// displayed in a drawing object (like a text box) that is separate from, but
+// associated with, a cell. Comments are used as reminders, such as noting how a
+// complex formula works, or to provide feedback to other users. Comments can
+// also be used to explain assumptions made in a formula or to call out
+// something special about the cell.
+type xlsxComments struct {
+	XMLName     xml.Name        `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main comments"`
+	Authors     []xlsxAuthor    `xml:"authors"`
+	CommentList xlsxCommentList `xml:"commentList"`
+}
+
+// xlsxAuthor directly maps the author element. This element holds a string
+// representing the name of a single author of comments. Every comment shall
+// have an author. The maximum length of the author string is an implementation
+// detail, but a good guideline is 255 chars.
+type xlsxAuthor struct {
+	Author string `xml:"author"`
+}
+
+// xlsxCommentList (List of Comments) directly maps the xlsxCommentList element.
+// This element is a container that holds a list of comments for the sheet.
+type xlsxCommentList struct {
+	Comment []xlsxComment `xml:"comment"`
+}
+
+// xlsxComment directly maps the comment element. This element represents a
+// single user entered comment. Each comment shall have an author and can
+// optionally contain richly formatted text.
+type xlsxComment struct {
+	Ref      string   `xml:"ref,attr"`
+	AuthorID int      `xml:"authorId,attr"`
+	Text     xlsxText `xml:"text"`
+}
+
+// xlsxText directly maps the text element. This element contains rich text
+// which represents the text of a comment. The maximum length for this text is a
+// spreadsheet application implementation detail. A recommended guideline is
+// 32767 chars.
+type xlsxText struct {
+	R []xlsxR `xml:"r"`
+}
+
+// formatComment directly maps the format settings of the comment.
+type formatComment struct {
+	Author string `json:"author"`
+	Text   string `json:"text"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlContentTypes.go

@@ -0,0 +1,26 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxTypes directly maps the types element of content types for relationship
+// parts, it takes a Multipurpose Internet Mail Extension (MIME) media type as a
+// value.
+type xlsxTypes struct {
+	XMLName   xml.Name       `xml:"http://schemas.openxmlformats.org/package/2006/content-types Types"`
+	Overrides []xlsxOverride `xml:"Override"`
+	Defaults  []xlsxDefault  `xml:"Default"`
+}
+
+// xlsxOverride directly maps the override element in the namespace
+// http://schemas.openxmlformats.org/package/2006/content-types
+type xlsxOverride struct {
+	PartName    string `xml:",attr"`
+	ContentType string `xml:",attr"`
+}
+
+// xlsxDefault directly maps the default element in the namespace
+// http://schemas.openxmlformats.org/package/2006/content-types
+type xlsxDefault struct {
+	Extension   string `xml:",attr"`
+	ContentType string `xml:",attr"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlDecodeDrawing.go

@@ -0,0 +1,187 @@
+package excelize
+
+import "encoding/xml"
+
+// decodeCellAnchor directly maps the oneCellAnchor (One Cell Anchor Shape Size)
+// and twoCellAnchor (Two Cell Anchor Shape Size). This element specifies a two
+// cell anchor placeholder for a group, a shape, or a drawing element. It moves
+// with cells and its extents are in EMU units.
+type decodeCellAnchor struct {
+	EditAs  string `xml:"editAs,attr,omitempty"`
+	Content string `xml:",innerxml"`
+}
+
+// decodeWsDr directly maps the root element for a part of this content type
+// shall wsDr. In order to solve the problem that the label structure is changed
+// after serialization and deserialization, two different structures are
+// defined. decodeWsDr just for deserialization.
+type decodeWsDr struct {
+	A             string              `xml:"xmlns a,attr"`
+	Xdr           string              `xml:"xmlns xdr,attr"`
+	R             string              `xml:"xmlns r,attr"`
+	OneCellAnchor []*decodeCellAnchor `xml:"oneCellAnchor,omitempty"`
+	TwoCellAnchor []*decodeCellAnchor `xml:"twoCellAnchor,omitempty"`
+	XMLName       xml.Name            `xml:"http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing wsDr,omitempty"`
+}
+
+// decodeTwoCellAnchor directly maps the oneCellAnchor (One Cell Anchor Shape
+// Size) and twoCellAnchor (Two Cell Anchor Shape Size). This element specifies
+// a two cell anchor placeholder for a group, a shape, or a drawing element. It
+// moves with cells and its extents are in EMU units.
+type decodeTwoCellAnchor struct {
+	From       *decodeFrom       `xml:"from"`
+	To         *decodeTo         `xml:"to"`
+	Pic        *decodePic        `xml:"pic,omitempty"`
+	ClientData *decodeClientData `xml:"clientData"`
+}
+
+// decodeCNvPr directly maps the cNvPr (Non-Visual Drawing Properties). This
+// element specifies non-visual canvas properties. This allows for additional
+// information that does not affect the appearance of the picture to be stored.
+type decodeCNvPr struct {
+	ID    int    `xml:"id,attr"`
+	Name  string `xml:"name,attr"`
+	Descr string `xml:"descr,attr"`
+	Title string `xml:"title,attr,omitempty"`
+}
+
+// decodePicLocks directly maps the picLocks (Picture Locks). This element
+// specifies all locking properties for a graphic frame. These properties inform
+// the generating application about specific properties that have been
+// previously locked and thus should not be changed.
+type decodePicLocks struct {
+	NoAdjustHandles    bool `xml:"noAdjustHandles,attr,omitempty"`
+	NoChangeArrowheads bool `xml:"noChangeArrowheads,attr,omitempty"`
+	NoChangeAspect     bool `xml:"noChangeAspect,attr"`
+	NoChangeShapeType  bool `xml:"noChangeShapeType,attr,omitempty"`
+	NoCrop             bool `xml:"noCrop,attr,omitempty"`
+	NoEditPoints       bool `xml:"noEditPoints,attr,omitempty"`
+	NoGrp              bool `xml:"noGrp,attr,omitempty"`
+	NoMove             bool `xml:"noMove,attr,omitempty"`
+	NoResize           bool `xml:"noResize,attr,omitempty"`
+	NoRot              bool `xml:"noRot,attr,omitempty"`
+	NoSelect           bool `xml:"noSelect,attr,omitempty"`
+}
+
+// decodeBlip directly maps the blip element in the namespace
+// http://purl.oclc.org/ooxml/officeDoc ument/relationships - This element
+// specifies the existence of an image (binary large image or picture) and
+// contains a reference to the image data.
+type decodeBlip struct {
+	Embed  string `xml:"embed,attr"`
+	Cstate string `xml:"cstate,attr,omitempty"`
+	R      string `xml:"r,attr"`
+}
+
+// decodeStretch directly maps the stretch element. This element specifies that
+// a BLIP should be stretched to fill the target rectangle. The other option is
+// a tile where a BLIP is tiled to fill the available area.
+type decodeStretch struct {
+	FillRect string `xml:"fillRect"`
+}
+
+// decodeOff directly maps the colOff and rowOff element. This element is used
+// to specify the column offset within a cell.
+type decodeOff struct {
+	X int `xml:"x,attr"`
+	Y int `xml:"y,attr"`
+}
+
+// decodeExt directly maps the ext element.
+type decodeExt struct {
+	Cx int `xml:"cx,attr"`
+	Cy int `xml:"cy,attr"`
+}
+
+// decodePrstGeom directly maps the prstGeom (Preset geometry). This element
+// specifies when a preset geometric shape should be used instead of a custom
+// geometric shape. The generating application should be able to render all
+// preset geometries enumerated in the ST_ShapeType list.
+type decodePrstGeom struct {
+	Prst string `xml:"prst,attr"`
+}
+
+// decodeXfrm directly maps the xfrm (2D Transform for Graphic Frame). This
+// element specifies the transform to be applied to the corresponding graphic
+// frame. This transformation is applied to the graphic frame just as it would
+// be for a shape or group shape.
+type decodeXfrm struct {
+	Off decodeOff `xml:"off"`
+	Ext decodeExt `xml:"ext"`
+}
+
+// decodeCNvPicPr directly maps the cNvPicPr (Non-Visual Picture Drawing
+// Properties). This element specifies the non-visual properties for the picture
+// canvas. These properties are to be used by the generating application to
+// determine how certain properties are to be changed for the picture object in
+// question.
+type decodeCNvPicPr struct {
+	PicLocks decodePicLocks `xml:"picLocks"`
+}
+
+// directly maps the nvPicPr (Non-Visual Properties for a Picture). This element
+// specifies all non-visual properties for a picture. This element is a
+// container for the non-visual identification properties, shape properties and
+// application properties that are to be associated with a picture. This allows
+// for additional information that does not affect the appearance of the picture
+// to be stored.
+type decodeNvPicPr struct {
+	CNvPr    decodeCNvPr    `xml:"cNvPr"`
+	CNvPicPr decodeCNvPicPr `xml:"cNvPicPr"`
+}
+
+// decodeBlipFill directly maps the blipFill (Picture Fill). This element
+// specifies the kind of picture fill that the picture object has. Because a
+// picture has a picture fill already by default, it is possible to have two
+// fills specified for a picture object.
+type decodeBlipFill struct {
+	Blip    decodeBlip    `xml:"blip"`
+	Stretch decodeStretch `xml:"stretch"`
+}
+
+// decodeSpPr directly maps the spPr (Shape Properties). This element specifies
+// the visual shape properties that can be applied to a picture. These are the
+// same properties that are allowed to describe the visual properties of a shape
+// but are used here to describe the visual appearance of a picture within a
+// document.
+type decodeSpPr struct {
+	Xfrm     decodeXfrm     `xml:"a:xfrm"`
+	PrstGeom decodePrstGeom `xml:"a:prstGeom"`
+}
+
+// decodePic elements encompass the definition of pictures within the DrawingML
+// framework. While pictures are in many ways very similar to shapes they have
+// specific properties that are unique in order to optimize for picture-
+// specific scenarios.
+type decodePic struct {
+	NvPicPr  decodeNvPicPr  `xml:"nvPicPr"`
+	BlipFill decodeBlipFill `xml:"blipFill"`
+	SpPr     decodeSpPr     `xml:"spPr"`
+}
+
+// decodeFrom specifies the starting anchor.
+type decodeFrom struct {
+	Col    int `xml:"col"`
+	ColOff int `xml:"colOff"`
+	Row    int `xml:"row"`
+	RowOff int `xml:"rowOff"`
+}
+
+// decodeTo directly specifies the ending anchor.
+type decodeTo struct {
+	Col    int `xml:"col"`
+	ColOff int `xml:"colOff"`
+	Row    int `xml:"row"`
+	RowOff int `xml:"rowOff"`
+}
+
+// decodeClientData directly maps the clientData element. An empty element which
+// specifies (via attributes) certain properties related to printing and
+// selection of the drawing object. The fLocksWithSheet attribute (either true
+// or false) determines whether to disable selection when the sheet is
+// protected, and fPrintsWithSheet attribute (either true or false) determines
+// whether the object is printed when the sheet is printed.
+type decodeClientData struct {
+	FLocksWithSheet  bool `xml:"fLocksWithSheet,attr"`
+	FPrintsWithSheet bool `xml:"fPrintsWithSheet,attr"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlDrawing.go

@@ -0,0 +1,388 @@
+package excelize
+
+import "encoding/xml"
+
+// Source relationship and namespace.
+const (
+	SourceRelationship              = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+	SourceRelationshipChart         = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart"
+	SourceRelationshipComments      = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments"
+	SourceRelationshipImage         = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"
+	SourceRelationshipTable         = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/table"
+	SourceRelationshipDrawingML     = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing"
+	SourceRelationshipDrawingVML    = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing"
+	SourceRelationshipHyperLink     = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+	SourceRelationshipWorkSheet     = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"
+	SourceRelationshipChart201506   = "http://schemas.microsoft.com/office/drawing/2015/06/chart"
+	SourceRelationshipChart20070802 = "http://schemas.microsoft.com/office/drawing/2007/8/2/chart"
+	SourceRelationshipChart2014     = "http://schemas.microsoft.com/office/drawing/2014/chart"
+	SourceRelationshipCompatibility = "http://schemas.openxmlformats.org/markup-compatibility/2006"
+	NameSpaceDrawingML              = "http://schemas.openxmlformats.org/drawingml/2006/main"
+	NameSpaceDrawingMLChart         = "http://schemas.openxmlformats.org/drawingml/2006/chart"
+	NameSpaceDrawingMLSpreadSheet   = "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"
+	NameSpaceSpreadSheet            = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+	NameSpaceXML                    = "http://www.w3.org/XML/1998/namespace"
+)
+
+var supportImageTypes = map[string]string{".gif": ".gif", ".jpg": ".jpeg", ".jpeg": ".jpeg", ".png": ".png"}
+
+// xlsxCNvPr directly maps the cNvPr (Non-Visual Drawing Properties). This
+// element specifies non-visual canvas properties. This allows for additional
+// information that does not affect the appearance of the picture to be stored.
+type xlsxCNvPr struct {
+	ID         int             `xml:"id,attr"`
+	Name       string          `xml:"name,attr"`
+	Descr      string          `xml:"descr,attr"`
+	Title      string          `xml:"title,attr,omitempty"`
+	HlinkClick *xlsxHlinkClick `xml:"a:hlinkClick"`
+}
+
+// xlsxHlinkClick (Click Hyperlink) Specifies the on-click hyperlink
+// information to be applied to a run of text. When the hyperlink text is
+// clicked the link is fetched.
+type xlsxHlinkClick struct {
+	R              string `xml:"xmlns:r,attr,omitempty"`
+	RID            string `xml:"r:id,attr,omitempty"`
+	InvalidURL     string `xml:"invalidUrl,attr,omitempty"`
+	Action         string `xml:"action,attr,omitempty"`
+	TgtFrame       string `xml:"tgtFrame,attr,omitempty"`
+	Tooltip        string `xml:"tooltip,attr,omitempty"`
+	History        bool   `xml:"history,attr,omitempty"`
+	HighlightClick bool   `xml:"highlightClick,attr,omitempty"`
+	EndSnd         bool   `xml:"endSnd,attr,omitempty"`
+}
+
+// xlsxPicLocks directly maps the picLocks (Picture Locks). This element
+// specifies all locking properties for a graphic frame. These properties inform
+// the generating application about specific properties that have been
+// previously locked and thus should not be changed.
+type xlsxPicLocks struct {
+	NoAdjustHandles    bool `xml:"noAdjustHandles,attr,omitempty"`
+	NoChangeArrowheads bool `xml:"noChangeArrowheads,attr,omitempty"`
+	NoChangeAspect     bool `xml:"noChangeAspect,attr"`
+	NoChangeShapeType  bool `xml:"noChangeShapeType,attr,omitempty"`
+	NoCrop             bool `xml:"noCrop,attr,omitempty"`
+	NoEditPoints       bool `xml:"noEditPoints,attr,omitempty"`
+	NoGrp              bool `xml:"noGrp,attr,omitempty"`
+	NoMove             bool `xml:"noMove,attr,omitempty"`
+	NoResize           bool `xml:"noResize,attr,omitempty"`
+	NoRot              bool `xml:"noRot,attr,omitempty"`
+	NoSelect           bool `xml:"noSelect,attr,omitempty"`
+}
+
+// xlsxBlip directly maps the blip element in the namespace
+// http://purl.oclc.org/ooxml/officeDoc ument/relationships - This element
+// specifies the existence of an image (binary large image or picture) and
+// contains a reference to the image data.
+type xlsxBlip struct {
+	Embed  string `xml:"r:embed,attr"`
+	Cstate string `xml:"cstate,attr,omitempty"`
+	R      string `xml:"xmlns:r,attr"`
+}
+
+// xlsxStretch directly maps the stretch element. This element specifies that a
+// BLIP should be stretched to fill the target rectangle. The other option is a
+// tile where a BLIP is tiled to fill the available area.
+type xlsxStretch struct {
+	FillRect string `xml:"a:fillRect"`
+}
+
+// xlsxOff directly maps the colOff and rowOff element. This element is used to
+// specify the column offset within a cell.
+type xlsxOff struct {
+	X int `xml:"x,attr"`
+	Y int `xml:"y,attr"`
+}
+
+// xlsxExt directly maps the ext element.
+type xlsxExt struct {
+	Cx int `xml:"cx,attr"`
+	Cy int `xml:"cy,attr"`
+}
+
+// xlsxPrstGeom directly maps the prstGeom (Preset geometry). This element
+// specifies when a preset geometric shape should be used instead of a custom
+// geometric shape. The generating application should be able to render all
+// preset geometries enumerated in the ST_ShapeType list.
+type xlsxPrstGeom struct {
+	Prst string `xml:"prst,attr"`
+}
+
+// xlsxXfrm directly maps the xfrm (2D Transform for Graphic Frame). This
+// element specifies the transform to be applied to the corresponding graphic
+// frame. This transformation is applied to the graphic frame just as it would
+// be for a shape or group shape.
+type xlsxXfrm struct {
+	Off xlsxOff `xml:"a:off"`
+	Ext xlsxExt `xml:"a:ext"`
+}
+
+// xlsxCNvPicPr directly maps the cNvPicPr (Non-Visual Picture Drawing
+// Properties). This element specifies the non-visual properties for the picture
+// canvas. These properties are to be used by the generating application to
+// determine how certain properties are to be changed for the picture object in
+// question.
+type xlsxCNvPicPr struct {
+	PicLocks xlsxPicLocks `xml:"a:picLocks"`
+}
+
+// directly maps the nvPicPr (Non-Visual Properties for a Picture). This element
+// specifies all non-visual properties for a picture. This element is a
+// container for the non-visual identification properties, shape properties and
+// application properties that are to be associated with a picture. This allows
+// for additional information that does not affect the appearance of the picture
+// to be stored.
+type xlsxNvPicPr struct {
+	CNvPr    xlsxCNvPr    `xml:"xdr:cNvPr"`
+	CNvPicPr xlsxCNvPicPr `xml:"xdr:cNvPicPr"`
+}
+
+// xlsxBlipFill directly maps the blipFill (Picture Fill). This element
+// specifies the kind of picture fill that the picture object has. Because a
+// picture has a picture fill already by default, it is possible to have two
+// fills specified for a picture object.
+type xlsxBlipFill struct {
+	Blip    xlsxBlip    `xml:"a:blip"`
+	Stretch xlsxStretch `xml:"a:stretch"`
+}
+
+// xlsxSpPr directly maps the spPr (Shape Properties). This element specifies
+// the visual shape properties that can be applied to a picture. These are the
+// same properties that are allowed to describe the visual properties of a shape
+// but are used here to describe the visual appearance of a picture within a
+// document.
+type xlsxSpPr struct {
+	Xfrm     xlsxXfrm     `xml:"a:xfrm"`
+	PrstGeom xlsxPrstGeom `xml:"a:prstGeom"`
+}
+
+// xlsxPic elements encompass the definition of pictures within the DrawingML
+// framework. While pictures are in many ways very similar to shapes they have
+// specific properties that are unique in order to optimize for picture-
+// specific scenarios.
+type xlsxPic struct {
+	NvPicPr  xlsxNvPicPr  `xml:"xdr:nvPicPr"`
+	BlipFill xlsxBlipFill `xml:"xdr:blipFill"`
+	SpPr     xlsxSpPr     `xml:"xdr:spPr"`
+}
+
+// xlsxFrom specifies the starting anchor.
+type xlsxFrom struct {
+	Col    int `xml:"xdr:col"`
+	ColOff int `xml:"xdr:colOff"`
+	Row    int `xml:"xdr:row"`
+	RowOff int `xml:"xdr:rowOff"`
+}
+
+// xlsxTo directly specifies the ending anchor.
+type xlsxTo struct {
+	Col    int `xml:"xdr:col"`
+	ColOff int `xml:"xdr:colOff"`
+	Row    int `xml:"xdr:row"`
+	RowOff int `xml:"xdr:rowOff"`
+}
+
+// xdrClientData directly maps the clientData element. An empty element which
+// specifies (via attributes) certain properties related to printing and
+// selection of the drawing object. The fLocksWithSheet attribute (either true
+// or false) determines whether to disable selection when the sheet is
+// protected, and fPrintsWithSheet attribute (either true or false) determines
+// whether the object is printed when the sheet is printed.
+type xdrClientData struct {
+	FLocksWithSheet  bool `xml:"fLocksWithSheet,attr"`
+	FPrintsWithSheet bool `xml:"fPrintsWithSheet,attr"`
+}
+
+// xdrCellAnchor directly maps the oneCellAnchor (One Cell Anchor Shape Size)
+// and twoCellAnchor (Two Cell Anchor Shape Size). This element specifies a two
+// cell anchor placeholder for a group, a shape, or a drawing element. It moves
+// with cells and its extents are in EMU units.
+type xdrCellAnchor struct {
+	EditAs       string         `xml:"editAs,attr,omitempty"`
+	From         *xlsxFrom      `xml:"xdr:from"`
+	To           *xlsxTo        `xml:"xdr:to"`
+	Ext          *xlsxExt       `xml:"xdr:ext"`
+	Sp           *xdrSp         `xml:"xdr:sp"`
+	Pic          *xlsxPic       `xml:"xdr:pic,omitempty"`
+	GraphicFrame string         `xml:",innerxml"`
+	ClientData   *xdrClientData `xml:"xdr:clientData"`
+}
+
+// xlsxWsDr directly maps the root element for a part of this content type shall
+// wsDr.
+type xlsxWsDr struct {
+	XMLName       xml.Name         `xml:"xdr:wsDr"`
+	OneCellAnchor []*xdrCellAnchor `xml:"xdr:oneCellAnchor"`
+	TwoCellAnchor []*xdrCellAnchor `xml:"xdr:twoCellAnchor"`
+	A             string           `xml:"xmlns:a,attr,omitempty"`
+	Xdr           string           `xml:"xmlns:xdr,attr,omitempty"`
+	R             string           `xml:"xmlns:r,attr,omitempty"`
+}
+
+// xlsxGraphicFrame (Graphic Frame) directly maps the xdr:graphicFrame element.
+// This element specifies the existence of a graphics frame. This frame contains
+// a graphic that was generated by an external source and needs a container in
+// which to be displayed on the slide surface.
+type xlsxGraphicFrame struct {
+	XMLName          xml.Name             `xml:"xdr:graphicFrame"`
+	Macro            string               `xml:"macro,attr"`
+	NvGraphicFramePr xlsxNvGraphicFramePr `xml:"xdr:nvGraphicFramePr"`
+	Xfrm             xlsxXfrm             `xml:"xdr:xfrm"`
+	Graphic          *xlsxGraphic         `xml:"a:graphic"`
+}
+
+// xlsxNvGraphicFramePr (Non-Visual Properties for a Graphic Frame) directly
+// maps the xdr:nvGraphicFramePr element. This element specifies all non-visual
+// properties for a graphic frame. This element is a container for the non-
+// visual identification properties, shape properties and application properties
+// that are to be associated with a graphic frame. This allows for additional
+// information that does not affect the appearance of the graphic frame to be
+// stored.
+type xlsxNvGraphicFramePr struct {
+	CNvPr                *xlsxCNvPr `xml:"xdr:cNvPr"`
+	ChicNvGraphicFramePr string     `xml:"xdr:cNvGraphicFramePr"`
+}
+
+// xlsxGraphic (Graphic Object) directly maps the a:graphic element. This
+// element specifies the existence of a single graphic object. Document authors
+// should refer to this element when they wish to persist a graphical object of
+// some kind. The specification for this graphical object is provided entirely
+// by the document author and referenced within the graphicData child element.
+type xlsxGraphic struct {
+	GraphicData *xlsxGraphicData `xml:"a:graphicData"`
+}
+
+// xlsxGraphicData (Graphic Object Data) directly maps the a:graphicData
+// element. This element specifies the reference to a graphic object within the
+// document. This graphic object is provided entirely by the document authors
+// who choose to persist this data within the document.
+type xlsxGraphicData struct {
+	URI   string     `xml:"uri,attr"`
+	Chart *xlsxChart `xml:"c:chart,omitempty"`
+}
+
+// xlsxChart (Chart) directly maps the c:chart element.
+type xlsxChart struct {
+	C   string `xml:"xmlns:c,attr"`
+	RID string `xml:"r:id,attr"`
+	R   string `xml:"xmlns:r,attr"`
+}
+
+// xdrSp (Shape) directly maps the xdr:sp element. This element specifies the
+// existence of a single shape. A shape can either be a preset or a custom
+// geometry, defined using the SpreadsheetDrawingML framework. In addition to a
+// geometry each shape can have both visual and non-visual properties attached.
+// Text and corresponding styling information can also be attached to a shape.
+// This shape is specified along with all other shapes within either the shape
+// tree or group shape elements.
+type xdrSp struct {
+	Macro    string     `xml:"macro,attr"`
+	Textlink string     `xml:"textlink,attr"`
+	NvSpPr   *xdrNvSpPr `xml:"xdr:nvSpPr"`
+	SpPr     *xlsxSpPr  `xml:"xdr:spPr"`
+	Style    *xdrStyle  `xml:"xdr:style"`
+	TxBody   *xdrTxBody `xml:"xdr:txBody"`
+}
+
+// xdrNvSpPr (Non-Visual Properties for a Shape) directly maps the xdr:nvSpPr
+// element. This element specifies all non-visual properties for a shape. This
+// element is a container for the non-visual identification properties, shape
+// properties and application properties that are to be associated with a shape.
+// This allows for additional information that does not affect the appearance of
+// the shape to be stored.
+type xdrNvSpPr struct {
+	CNvPr   *xlsxCNvPr  `xml:"xdr:cNvPr"`
+	CNvSpPr *xdrCNvSpPr `xml:"xdr:cNvSpPr"`
+}
+
+// xdrCNvSpPr (Connection Non-Visual Shape Properties) directly maps the
+// xdr:cNvSpPr element. This element specifies the set of non-visual properties
+// for a connection shape. These properties specify all data about the
+// connection shape which do not affect its display within a spreadsheet.
+type xdrCNvSpPr struct {
+	TxBox bool `xml:"txBox,attr"`
+}
+
+// xdrStyle (Shape Style) directly maps the xdr:style element. The element
+// specifies the style that is applied to a shape and the corresponding
+// references for each of the style components such as lines and fills.
+type xdrStyle struct {
+	LnRef     *aRef     `xml:"a:lnRef"`
+	FillRef   *aRef     `xml:"a:fillRef"`
+	EffectRef *aRef     `xml:"a:effectRef"`
+	FontRef   *aFontRef `xml:"a:fontRef"`
+}
+
+// aRef directly maps the a:lnRef, a:fillRef and a:effectRef element.
+type aRef struct {
+	Idx       int            `xml:"idx,attr"`
+	ScrgbClr  *aScrgbClr     `xml:"a:scrgbClr"`
+	SchemeClr *attrValString `xml:"a:schemeClr"`
+	SrgbClr   *attrValString `xml:"a:srgbClr"`
+}
+
+// aScrgbClr (RGB Color Model - Percentage Variant) directly maps the a:scrgbClr
+// element. This element specifies a color using the red, green, blue RGB color
+// model. Each component, red, green, and blue is expressed as a percentage from
+// 0% to 100%. A linear gamma of 1.0 is assumed.
+type aScrgbClr struct {
+	R float64 `xml:"r,attr"`
+	G float64 `xml:"g,attr"`
+	B float64 `xml:"b,attr"`
+}
+
+// aFontRef (Font Reference) directly maps the a:fontRef element. This element
+// represents a reference to a themed font. When used it specifies which themed
+// font to use along with a choice of color.
+type aFontRef struct {
+	Idx       string         `xml:"idx,attr"`
+	SchemeClr *attrValString `xml:"a:schemeClr"`
+}
+
+// xdrTxBody (Shape Text Body) directly maps the xdr:txBody element. This
+// element specifies the existence of text to be contained within the
+// corresponding shape. All visible text and visible text related properties are
+// contained within this element. There can be multiple paragraphs and within
+// paragraphs multiple runs of text.
+type xdrTxBody struct {
+	BodyPr *aBodyPr `xml:"a:bodyPr"`
+	P      []*aP    `xml:"a:p"`
+}
+
+// formatPicture directly maps the format settings of the picture.
+type formatPicture struct {
+	FPrintsWithSheet bool    `json:"print_obj"`
+	FLocksWithSheet  bool    `json:"locked"`
+	NoChangeAspect   bool    `json:"lock_aspect_ratio"`
+	OffsetX          int     `json:"x_offset"`
+	OffsetY          int     `json:"y_offset"`
+	XScale           float64 `json:"x_scale"`
+	YScale           float64 `json:"y_scale"`
+	Hyperlink        string  `json:"hyperlink"`
+	HyperlinkType    string  `json:"hyperlink_type"`
+	Positioning      string  `json:"positioning"`
+}
+
+// formatShape directly maps the format settings of the shape.
+type formatShape struct {
+	Type      string                 `json:"type"`
+	Width     int                    `json:"width"`
+	Height    int                    `json:"height"`
+	Format    formatPicture          `json:"format"`
+	Color     formatShapeColor       `json:"color"`
+	Paragraph []formatShapeParagraph `json:"paragraph"`
+}
+
+// formatShapeParagraph directly maps the format settings of the paragraph in
+// the shape.
+type formatShapeParagraph struct {
+	Font formatFont `json:"font"`
+	Text string     `json:"text"`
+}
+
+// formatShapeColor directly maps the color settings of the shape.
+type formatShapeColor struct {
+	Line   string `json:"line"`
+	Fill   string `json:"fill"`
+	Effect string `json:"effect"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlSharedStrings.go

@@ -0,0 +1,46 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxSST directly maps the sst element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main. String values may
+// be stored directly inside spreadsheet cell elements; however, storing the
+// same value inside multiple cell elements can result in very large worksheet
+// Parts, possibly resulting in performance degradation. The Shared String Table
+// is an indexed list of string values, shared across the workbook, which allows
+// implementations to store values only once.
+type xlsxSST struct {
+	XMLName     xml.Name `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main sst"`
+	Count       int      `xml:"count,attr"`
+	UniqueCount int      `xml:"uniqueCount,attr"`
+	SI          []xlsxSI `xml:"si"`
+}
+
+// xlsxSI directly maps the si element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked this for completeness - it does as much as I need.
+type xlsxSI struct {
+	T string  `xml:"t"`
+	R []xlsxR `xml:"r"`
+}
+
+// xlsxR directly maps the r element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked this for completeness - it does as much as I need.
+type xlsxR struct {
+	RPr *xlsxRPr `xml:"rPr"`
+	T   string   `xml:"t"`
+}
+
+// xlsxRPr (Run Properties) specifies a set of run properties which shall be
+// applied to the contents of the parent run after all style formatting has been
+// applied to the text. These properties are defined as direct formatting, since
+// they are directly applied to the run and supersede any formatting from
+// styles.
+type xlsxRPr struct {
+	B      string         `xml:"b,omitempty"`
+	Sz     *attrValFloat  `xml:"sz"`
+	Color  *xlsxColor     `xml:"color"`
+	RFont  *attrValString `xml:"rFont"`
+	Family *attrValInt    `xml:"family"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlStyles.go

@@ -0,0 +1,356 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxStyleSheet directly maps the stylesheet element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxStyleSheet struct {
+	XMLName      xml.Name          `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main styleSheet"`
+	NumFmts      *xlsxNumFmts      `xml:"numFmts,omitempty"`
+	Fonts        *xlsxFonts        `xml:"fonts,omitempty"`
+	Fills        *xlsxFills        `xml:"fills,omitempty"`
+	Borders      *xlsxBorders      `xml:"borders,omitempty"`
+	CellStyleXfs *xlsxCellStyleXfs `xml:"cellStyleXfs,omitempty"`
+	CellXfs      *xlsxCellXfs      `xml:"cellXfs,omitempty"`
+	CellStyles   *xlsxCellStyles   `xml:"cellStyles,omitempty"`
+	Dxfs         *xlsxDxfs         `xml:"dxfs,omitempty"`
+	TableStyles  *xlsxTableStyles  `xml:"tableStyles,omitempty"`
+	Colors       *xlsxStyleColors  `xml:"colors,omitempty"`
+	ExtLst       *xlsxExtLst       `xml:"extLst"`
+}
+
+// xlsxAlignment formatting information pertaining to text alignment in cells.
+// There are a variety of choices for how text is aligned both horizontally and
+// vertically, as well as indentation settings, and so on.
+type xlsxAlignment struct {
+	Horizontal      string `xml:"horizontal,attr,omitempty"`
+	Indent          int    `xml:"indent,attr,omitempty"`
+	JustifyLastLine bool   `xml:"justifyLastLine,attr,omitempty"`
+	ReadingOrder    uint64 `xml:"readingOrder,attr,omitempty"`
+	RelativeIndent  int    `xml:"relativeIndent,attr,omitempty"`
+	ShrinkToFit     bool   `xml:"shrinkToFit,attr,omitempty"`
+	TextRotation    int    `xml:"textRotation,attr,omitempty"`
+	Vertical        string `xml:"vertical,attr,omitempty"`
+	WrapText        bool   `xml:"wrapText,attr,omitempty"`
+}
+
+// xlsxProtection (Protection Properties) contains protection properties
+// associated with the cell. Each cell has protection properties that can be
+// set. The cell protection properties do not take effect unless the sheet has
+// been protected.
+type xlsxProtection struct {
+	Hidden bool `xml:"hidden,attr"`
+	Locked bool `xml:"locked,attr"`
+}
+
+// xlsxLine directly maps the line style element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxLine struct {
+	Style string     `xml:"style,attr,omitempty"`
+	Color *xlsxColor `xml:"color,omitempty"`
+}
+
+// xlsxColor is a common mapping used for both the fgColor and bgColor elements.
+// Foreground color of the cell fill pattern. Cell fill patterns operate with
+// two colors: a background color and a foreground color. These combine together
+// to make a patterned cell fill. Background color of the cell fill pattern.
+// Cell fill patterns operate with two colors: a background color and a
+// foreground color. These combine together to make a patterned cell fill.
+type xlsxColor struct {
+	Auto    bool    `xml:"auto,attr,omitempty"`
+	RGB     string  `xml:"rgb,attr,omitempty"`
+	Indexed int     `xml:"indexed,attr,omitempty"`
+	Theme   *int    `xml:"theme,attr"`
+	Tint    float64 `xml:"tint,attr,omitempty"`
+}
+
+// xlsxFonts directly maps the font element. This element contains all font
+// definitions for this workbook.
+type xlsxFonts struct {
+	Count int         `xml:"count,attr"`
+	Font  []*xlsxFont `xml:"font"`
+}
+
+// font directly maps the font element.
+type font struct {
+	Name     *attrValString `xml:"name"`
+	Charset  *attrValInt    `xml:"charset"`
+	Family   *attrValInt    `xml:"family"`
+	B        bool           `xml:"b,omitempty"`
+	I        bool           `xml:"i,omitempty"`
+	Strike   bool           `xml:"strike,omitempty"`
+	Outline  bool           `xml:"outline,omitempty"`
+	Shadow   bool           `xml:"shadow,omitempty"`
+	Condense bool           `xml:"condense,omitempty"`
+	Extend   bool           `xml:"extend,omitempty"`
+	Color    *xlsxColor     `xml:"color"`
+	Sz       *attrValInt    `xml:"sz"`
+	U        *attrValString `xml:"u"`
+	Scheme   *attrValString `xml:"scheme"`
+}
+
+// xlsxFont directly maps the font element. This element defines the properties
+// for one of the fonts used in this workbook.
+type xlsxFont struct {
+	Font string `xml:",innerxml"`
+}
+
+// xlsxFills directly maps the fills element. This element defines the cell
+// fills portion of the Styles part, consisting of a sequence of fill records. A
+// cell fill consists of a background color, foreground color, and pattern to be
+// applied across the cell.
+type xlsxFills struct {
+	Count int         `xml:"count,attr"`
+	Fill  []*xlsxFill `xml:"fill,omitempty"`
+}
+
+// xlsxFill directly maps the fill element. This element specifies fill
+// formatting.
+type xlsxFill struct {
+	PatternFill  *xlsxPatternFill  `xml:"patternFill,omitempty"`
+	GradientFill *xlsxGradientFill `xml:"gradientFill,omitempty"`
+}
+
+// xlsxPatternFill directly maps the patternFill element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need. This element is
+// used to specify cell fill information for pattern and solid color cell fills.
+// For solid cell fills (no pattern), fgColor is used. For cell fills with
+// patterns specified, then the cell fill color is specified by the bgColor
+// element.
+type xlsxPatternFill struct {
+	PatternType string    `xml:"patternType,attr,omitempty"`
+	FgColor     xlsxColor `xml:"fgColor,omitempty"`
+	BgColor     xlsxColor `xml:"bgColor,omitempty"`
+}
+
+// xlsxGradientFill defines a gradient-style cell fill. Gradient cell fills can
+// use one or two colors as the end points of color interpolation.
+type xlsxGradientFill struct {
+	Bottom float64                 `xml:"bottom,attr,omitempty"`
+	Degree float64                 `xml:"degree,attr,omitempty"`
+	Left   float64                 `xml:"left,attr,omitempty"`
+	Right  float64                 `xml:"right,attr,omitempty"`
+	Top    float64                 `xml:"top,attr,omitempty"`
+	Type   string                  `xml:"type,attr,omitempty"`
+	Stop   []*xlsxGradientFillStop `xml:"stop,omitempty"`
+}
+
+// xlsxGradientFillStop directly maps the stop element.
+type xlsxGradientFillStop struct {
+	Position float64   `xml:"position,attr"`
+	Color    xlsxColor `xml:"color,omitempty"`
+}
+
+// xlsxBorders directly maps the borders element. This element contains borders
+// formatting information, specifying all border definitions for all cells in
+// the workbook.
+type xlsxBorders struct {
+	Count  int           `xml:"count,attr"`
+	Border []*xlsxBorder `xml:"border,omitempty"`
+}
+
+// xlsxBorder directly maps the border element. Expresses a single set of cell
+// border formats (left, right, top, bottom, diagonal). Color is optional. When
+// missing, 'automatic' is implied.
+type xlsxBorder struct {
+	DiagonalDown bool     `xml:"diagonalDown,attr,omitempty"`
+	DiagonalUp   bool     `xml:"diagonalUp,attr,omitempty"`
+	Outline      bool     `xml:"outline,attr,omitempty"`
+	Left         xlsxLine `xml:"left,omitempty"`
+	Right        xlsxLine `xml:"right,omitempty"`
+	Top          xlsxLine `xml:"top,omitempty"`
+	Bottom       xlsxLine `xml:"bottom,omitempty"`
+	Diagonal     xlsxLine `xml:"diagonal,omitempty"`
+}
+
+// xlsxCellStyles directly maps the cellStyles element. This element contains
+// the named cell styles, consisting of a sequence of named style records. A
+// named cell style is a collection of direct or themed formatting (e.g., cell
+// border, cell fill, and font type/size/style) grouped together into a single
+// named style, and can be applied to a cell.
+type xlsxCellStyles struct {
+	XMLName   xml.Name         `xml:"cellStyles"`
+	Count     int              `xml:"count,attr"`
+	CellStyle []*xlsxCellStyle `xml:"cellStyle,omitempty"`
+}
+
+// xlsxCellStyle directly maps the cellStyle element. This element represents
+// the name and related formatting records for a named cell style in this
+// workbook.
+type xlsxCellStyle struct {
+	XMLName       xml.Name `xml:"cellStyle"`
+	BuiltInID     *int     `xml:"builtinId,attr,omitempty"`
+	CustomBuiltIn *bool    `xml:"customBuiltin,attr,omitempty"`
+	Hidden        *bool    `xml:"hidden,attr,omitempty"`
+	ILevel        *bool    `xml:"iLevel,attr,omitempty"`
+	Name          string   `xml:"name,attr"`
+	XfID          int      `xml:"xfId,attr"`
+}
+
+// xlsxCellStyleXfs directly maps the cellStyleXfs element. This element
+// contains the master formatting records (xf's) which define the formatting for
+// all named cell styles in this workbook. Master formatting records reference
+// individual elements of formatting (e.g., number format, font definitions,
+// cell fills, etc) by specifying a zero-based index into those collections.
+// Master formatting records also specify whether to apply or ignore particular
+// aspects of formatting.
+type xlsxCellStyleXfs struct {
+	Count int      `xml:"count,attr"`
+	Xf    []xlsxXf `xml:"xf,omitempty"`
+}
+
+// xlsxXf directly maps the xf element. A single xf element describes all of the
+// formatting for a cell.
+type xlsxXf struct {
+	ApplyAlignment    bool            `xml:"applyAlignment,attr"`
+	ApplyBorder       bool            `xml:"applyBorder,attr"`
+	ApplyFill         bool            `xml:"applyFill,attr"`
+	ApplyFont         bool            `xml:"applyFont,attr"`
+	ApplyNumberFormat bool            `xml:"applyNumberFormat,attr"`
+	ApplyProtection   bool            `xml:"applyProtection,attr"`
+	BorderID          int             `xml:"borderId,attr"`
+	FillID            int             `xml:"fillId,attr"`
+	FontID            int             `xml:"fontId,attr"`
+	NumFmtID          int             `xml:"numFmtId,attr"`
+	PivotButton       bool            `xml:"pivotButton,attr,omitempty"`
+	QuotePrefix       bool            `xml:"quotePrefix,attr,omitempty"`
+	XfID              *int            `xml:"xfId,attr"`
+	Alignment         *xlsxAlignment  `xml:"alignment"`
+	Protection        *xlsxProtection `xml:"protection"`
+}
+
+// xlsxCellXfs directly maps the cellXfs element. This element contains the
+// master formatting records (xf) which define the formatting applied to cells
+// in this workbook. These records are the starting point for determining the
+// formatting for a cell. Cells in the Sheet Part reference the xf records by
+// zero-based index.
+type xlsxCellXfs struct {
+	Count int      `xml:"count,attr"`
+	Xf    []xlsxXf `xml:"xf,omitempty"`
+}
+
+// xlsxDxfs directly maps the dxfs element. This element contains the master
+// differential formatting records (dxf's) which define formatting for all non-
+// cell formatting in this workbook. Whereas xf records fully specify a
+// particular aspect of formatting (e.g., cell borders) by referencing those
+// formatting definitions elsewhere in the Styles part, dxf records specify
+// incremental (or differential) aspects of formatting directly inline within
+// the dxf element. The dxf formatting is to be applied on top of or in addition
+// to any formatting already present on the object using the dxf record.
+type xlsxDxfs struct {
+	Count int        `xml:"count,attr"`
+	Dxfs  []*xlsxDxf `xml:"dxf,omitempty"`
+}
+
+// xlsxDxf directly maps the dxf element. A single dxf record, expressing
+// incremental formatting to be applied.
+type xlsxDxf struct {
+	Dxf string `xml:",innerxml"`
+}
+
+// dxf directly maps the dxf element.
+type dxf struct {
+	Font       *font           `xml:"font"`
+	NumFmt     *xlsxNumFmt     `xml:"numFmt"`
+	Fill       *xlsxFill       `xml:"fill"`
+	Alignment  *xlsxAlignment  `xml:"alignment"`
+	Border     *xlsxBorder     `xml:"border"`
+	Protection *xlsxProtection `xml:"protection"`
+	ExtLst     *xlsxExt        `xml:"extLst"`
+}
+
+// xlsxTableStyles directly maps the tableStyles element. This element
+// represents a collection of Table style definitions for Table styles and
+// PivotTable styles used in this workbook. It consists of a sequence of
+// tableStyle records, each defining a single Table style.
+type xlsxTableStyles struct {
+	Count             int               `xml:"count,attr"`
+	DefaultPivotStyle string            `xml:"defaultPivotStyle,attr"`
+	DefaultTableStyle string            `xml:"defaultTableStyle,attr"`
+	TableStyles       []*xlsxTableStyle `xml:"tableStyle,omitempty"`
+}
+
+// xlsxTableStyle directly maps the tableStyle element. This element represents
+// a single table style definition that indicates how a spreadsheet application
+// should format and display a table.
+type xlsxTableStyle struct {
+	Name              string `xml:"name,attr,omitempty"`
+	Pivot             int    `xml:"pivot,attr"`
+	Count             int    `xml:"count,attr,omitempty"`
+	Table             bool   `xml:"table,attr,omitempty"`
+	TableStyleElement string `xml:",innerxml"`
+}
+
+// xlsxNumFmts directly maps the numFmts element. This element defines the
+// number formats in this workbook, consisting of a sequence of numFmt records,
+// where each numFmt record defines a particular number format, indicating how
+// to format and render the numeric value of a cell.
+type xlsxNumFmts struct {
+	Count  int           `xml:"count,attr"`
+	NumFmt []*xlsxNumFmt `xml:"numFmt,omitempty"`
+}
+
+// xlsxNumFmt directly maps the numFmt element. This element specifies number
+// format properties which indicate how to format and render the numeric value
+// of a cell.
+type xlsxNumFmt struct {
+	NumFmtID   int    `xml:"numFmtId,attr,omitempty"`
+	FormatCode string `xml:"formatCode,attr,omitempty"`
+}
+
+// xlsxStyleColors directly maps the colors element. Color information
+// associated with this stylesheet. This collection is written whenever the
+// legacy color palette has been modified (backwards compatibility settings) or
+// a custom color has been selected while using this workbook.
+type xlsxStyleColors struct {
+	Color string `xml:",innerxml"`
+}
+
+// formatFont directly maps the styles settings of the fonts.
+type formatFont struct {
+	Bold      bool   `json:"bold"`
+	Italic    bool   `json:"italic"`
+	Underline string `json:"underline"`
+	Family    string `json:"family"`
+	Size      int    `json:"size"`
+	Color     string `json:"color"`
+}
+
+// formatStyle directly maps the styles settings of the cells.
+type formatStyle struct {
+	Border []struct {
+		Type  string `json:"type"`
+		Color string `json:"color"`
+		Style int    `json:"style"`
+	} `json:"border"`
+	Fill struct {
+		Type    string   `json:"type"`
+		Pattern int      `json:"pattern"`
+		Color   []string `json:"color"`
+		Shading int      `json:"shading"`
+	} `json:"fill"`
+	Font      *formatFont `json:"font"`
+	Alignment *struct {
+		Horizontal      string `json:"horizontal"`
+		Indent          int    `json:"indent"`
+		JustifyLastLine bool   `json:"justify_last_line"`
+		ReadingOrder    uint64 `json:"reading_order"`
+		RelativeIndent  int    `json:"relative_indent"`
+		ShrinkToFit     bool   `json:"shrink_to_fit"`
+		TextRotation    int    `json:"text_rotation"`
+		Vertical        string `json:"vertical"`
+		WrapText        bool   `json:"wrap_text"`
+	} `json:"alignment"`
+	Protection *struct {
+		Hidden bool `json:"hidden"`
+		Locked bool `json:"locked"`
+	} `json:"protection"`
+	NumFmt        int     `json:"number_format"`
+	DecimalPlaces int     `json:"decimal_places"`
+	CustomNumFmt  *string `json:"custom_number_format"`
+	Lang          string  `json:"lang"`
+	NegRed        bool    `json:"negred"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlTable.go

@@ -0,0 +1,205 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxTable directly maps the table element. A table helps organize and provide
+// structure to lists of information in a worksheet. Tables have clearly labeled
+// columns, rows, and data regions. Tables make it easier for users to sort,
+// analyze, format, manage, add, and delete information. This element is the
+// root element for a table that is not a single cell XML table.
+type xlsxTable struct {
+	XMLName              xml.Name            `xml:"table"`
+	XMLNS                string              `xml:"xmlns,attr"`
+	DataCellStyle        string              `xml:"dataCellStyle,attr,omitempty"`
+	DataDxfID            int                 `xml:"dataDxfId,attr,omitempty"`
+	DisplayName          string              `xml:"displayName,attr,omitempty"`
+	HeaderRowBorderDxfID int                 `xml:"headerRowBorderDxfId,attr,omitempty"`
+	HeaderRowCellStyle   string              `xml:"headerRowCellStyle,attr,omitempty"`
+	HeaderRowCount       int                 `xml:"headerRowCount,attr,omitempty"`
+	HeaderRowDxfID       int                 `xml:"headerRowDxfId,attr,omitempty"`
+	ID                   int                 `xml:"id,attr"`
+	InsertRow            bool                `xml:"insertRow,attr,omitempty"`
+	InsertRowShift       bool                `xml:"insertRowShift,attr,omitempty"`
+	Name                 string              `xml:"name,attr"`
+	Published            bool                `xml:"published,attr,omitempty"`
+	Ref                  string              `xml:"ref,attr"`
+	TotalsRowCount       int                 `xml:"totalsRowCount,attr,omitempty"`
+	TotalsRowDxfID       int                 `xml:"totalsRowDxfId,attr,omitempty"`
+	TotalsRowShown       bool                `xml:"totalsRowShown,attr"`
+	AutoFilter           *xlsxAutoFilter     `xml:"autoFilter"`
+	TableColumns         *xlsxTableColumns   `xml:"tableColumns"`
+	TableStyleInfo       *xlsxTableStyleInfo `xml:"tableStyleInfo"`
+}
+
+// xlsxAutoFilter temporarily hides rows based on a filter criteria, which is
+// applied column by column to a table of data in the worksheet. This collection
+// expresses AutoFilter settings.
+type xlsxAutoFilter struct {
+	Ref          string            `xml:"ref,attr"`
+	FilterColumn *xlsxFilterColumn `xml:"filterColumn"`
+}
+
+// xlsxFilterColumn directly maps the filterColumn element. The filterColumn
+// collection identifies a particular column in the AutoFilter range and
+// specifies filter information that has been applied to this column. If a
+// column in the AutoFilter range has no criteria specified, then there is no
+// corresponding filterColumn collection expressed for that column.
+type xlsxFilterColumn struct {
+	ColID         int                `xml:"colId,attr"`
+	HiddenButton  bool               `xml:"hiddenButton,attr,omitempty"`
+	ShowButton    bool               `xml:"showButton,attr,omitempty"`
+	CustomFilters *xlsxCustomFilters `xml:"customFilters"`
+	Filters       *xlsxFilters       `xml:"filters"`
+	ColorFilter   *xlsxColorFilter   `xml:"colorFilter"`
+	DynamicFilter *xlsxDynamicFilter `xml:"dynamicFilter"`
+	IconFilter    *xlsxIconFilter    `xml:"iconFilter"`
+	Top10         *xlsxTop10         `xml:"top10"`
+}
+
+// xlsxCustomFilters directly maps the customFilters element. When there is more
+// than one custom filter criteria to apply (an 'and' or 'or' joining two
+// criteria), then this element groups the customFilter elements together.
+type xlsxCustomFilters struct {
+	And          bool                `xml:"and,attr,omitempty"`
+	CustomFilter []*xlsxCustomFilter `xml:"customFilter"`
+}
+
+// xlsxCustomFilter directly maps the customFilter element. A custom AutoFilter
+// specifies an operator and a value. There can be at most two customFilters
+// specified, and in that case the parent element specifies whether the two
+// conditions are joined by 'and' or 'or'. For any cells whose values do not
+// meet the specified criteria, the corresponding rows shall be hidden from view
+// when the filter is applied.
+type xlsxCustomFilter struct {
+	Operator string `xml:"operator,attr,omitempty"`
+	Val      string `xml:"val,attr,omitempty"`
+}
+
+// xlsxFilters directly maps the filters (Filter Criteria) element. When
+// multiple values are chosen to filter by, or when a group of date values are
+// chosen to filter by, this element groups those criteria together.
+type xlsxFilters struct {
+	Blank         bool                 `xml:"blank,attr,omitempty"`
+	CalendarType  string               `xml:"calendarType,attr,omitempty"`
+	Filter        []*xlsxFilter        `xml:"filter"`
+	DateGroupItem []*xlsxDateGroupItem `xml:"dateGroupItem"`
+}
+
+// xlsxFilter directly maps the filter element. This element expresses a filter
+// criteria value.
+type xlsxFilter struct {
+	Val string `xml:"val,attr,omitempty"`
+}
+
+// xlsxColorFilter directly maps the colorFilter element. This element specifies
+// the color to filter by and whether to use the cell's fill or font color in
+// the filter criteria. If the cell's font or fill color does not match the
+// color specified in the criteria, the rows corresponding to those cells are
+// hidden from view.
+type xlsxColorFilter struct {
+	CellColor bool `xml:"cellColor,attr"`
+	DxfID     int  `xml:"dxfId,attr"`
+}
+
+// xlsxDynamicFilter directly maps the dynamicFilter element. This collection
+// specifies dynamic filter criteria. These criteria are considered dynamic
+// because they can change, either with the data itself (e.g., "above average")
+// or with the current system date (e.g., show values for "today"). For any
+// cells whose values do not meet the specified criteria, the corresponding rows
+// shall be hidden from view when the filter is applied.
+type xlsxDynamicFilter struct {
+	MaxValISO string  `xml:"maxValIso,attr,omitempty"`
+	Type      string  `xml:"type,attr,omitempty"`
+	Val       float64 `xml:"val,attr,omitempty"`
+	ValISO    string  `xml:"valIso,attr,omitempty"`
+}
+
+// xlsxIconFilter directly maps the iconFilter element. This element specifies
+// the icon set and particular icon within that set to filter by. For any cells
+// whose icon does not match the specified criteria, the corresponding rows
+// shall be hidden from view when the filter is applied.
+type xlsxIconFilter struct {
+	IconID  int    `xml:"iconId,attr"`
+	IconSet string `xml:"iconSet,attr,omitempty"`
+}
+
+// xlsxTop10 directly maps the top10 element. This element specifies the top N
+// (percent or number of items) to filter by.
+type xlsxTop10 struct {
+	FilterVal float64 `xml:"filterVal,attr,omitempty"`
+	Percent   bool    `xml:"percent,attr,omitempty"`
+	Top       bool    `xml:"top,attr"`
+	Val       float64 `xml:"val,attr,omitempty"`
+}
+
+// xlsxDateGroupItem directly maps the dateGroupItem element. This collection is
+// used to express a group of dates or times which are used in an AutoFilter
+// criteria. [Note: See parent element for an example. end note] Values are
+// always written in the calendar type of the first date encountered in the
+// filter range, so that all subsequent dates, even when formatted or
+// represented by other calendar types, can be correctly compared for the
+// purposes of filtering.
+type xlsxDateGroupItem struct {
+	DateTimeGrouping string `xml:"dateTimeGrouping,attr,omitempty"`
+	Day              int    `xml:"day,attr,omitempty"`
+	Hour             int    `xml:"hour,attr,omitempty"`
+	Minute           int    `xml:"minute,attr,omitempty"`
+	Month            int    `xml:"month,attr,omitempty"`
+	Second           int    `xml:"second,attr,omitempty"`
+	Year             int    `xml:"year,attr,omitempty"`
+}
+
+// xlsxTableColumns directly maps the element representing the collection of all
+// table columns for this table.
+type xlsxTableColumns struct {
+	Count       int                `xml:"count,attr"`
+	TableColumn []*xlsxTableColumn `xml:"tableColumn"`
+}
+
+// xlsxTableColumn directly maps the element representing a single column for
+// this table.
+type xlsxTableColumn struct {
+	DataCellStyle      string `xml:"dataCellStyle,attr,omitempty"`
+	DataDxfID          int    `xml:"dataDxfId,attr,omitempty"`
+	HeaderRowCellStyle string `xml:"headerRowCellStyle,attr,omitempty"`
+	HeaderRowDxfID     int    `xml:"headerRowDxfId,attr,omitempty"`
+	ID                 int    `xml:"id,attr"`
+	Name               string `xml:"name,attr"`
+	QueryTableFieldID  int    `xml:"queryTableFieldId,attr,omitempty"`
+	TotalsRowCellStyle string `xml:"totalsRowCellStyle,attr,omitempty"`
+	TotalsRowDxfID     int    `xml:"totalsRowDxfId,attr,omitempty"`
+	TotalsRowFunction  string `xml:"totalsRowFunction,attr,omitempty"`
+	TotalsRowLabel     string `xml:"totalsRowLabel,attr,omitempty"`
+	UniqueName         string `xml:"uniqueName,attr,omitempty"`
+}
+
+// xlsxTableStyleInfo directly maps the tableStyleInfo element. This element
+// describes which style is used to display this table, and specifies which
+// portions of the table have the style applied.
+type xlsxTableStyleInfo struct {
+	Name              string `xml:"name,attr,omitempty"`
+	ShowFirstColumn   bool   `xml:"showFirstColumn,attr"`
+	ShowLastColumn    bool   `xml:"showLastColumn,attr"`
+	ShowRowStripes    bool   `xml:"showRowStripes,attr"`
+	ShowColumnStripes bool   `xml:"showColumnStripes,attr"`
+}
+
+// formatTable directly maps the format settings of the table.
+type formatTable struct {
+	TableName         string `json:"table_name"`
+	TableStyle        string `json:"table_style"`
+	ShowFirstColumn   bool   `json:"show_first_column"`
+	ShowLastColumn    bool   `json:"show_last_column"`
+	ShowRowStripes    bool   `json:"show_row_stripes"`
+	ShowColumnStripes bool   `json:"show_column_stripes"`
+}
+
+// formatAutoFilter directly maps the auto filter settings.
+type formatAutoFilter struct {
+	Column     string `json:"column"`
+	Expression string `json:"expression"`
+	FilterList []struct {
+		Column string `json:"column"`
+		Value  []int  `json:"value"`
+	} `json:"filter_list"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlTheme.go

@@ -0,0 +1,140 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxTheme directly maps the theme element in the namespace
+// http://schemas.openxmlformats.org/drawingml/2006/main
+type xlsxTheme struct {
+	ThemeElements     xlsxThemeElements     `xml:"themeElements"`
+	ObjectDefaults    xlsxObjectDefaults    `xml:"objectDefaults"`
+	ExtraClrSchemeLst xlsxExtraClrSchemeLst `xml:"extraClrSchemeLst"`
+	ExtLst            *xlsxExtLst           `xml:"extLst"`
+}
+
+// objectDefaults element allows for the definition of default shape, line,
+// and textbox formatting properties. An application can use this information
+// to format a shape (or text) initially on insertion into a document.
+type xlsxObjectDefaults struct {
+	ObjectDefaults string `xml:",innerxml"`
+}
+
+// xlsxExtraClrSchemeLst element is a container for the list of extra color
+// schemes present in a document.
+type xlsxExtraClrSchemeLst struct {
+	ExtraClrSchemeLst string `xml:",innerxml"`
+}
+
+// xlsxThemeElements directly maps the element defines the theme formatting
+// options for the theme and is the workhorse of the theme. This is where the
+// bulk of the shared theme information is contained and used by a document.
+// This element contains the color scheme, font scheme, and format scheme
+// elements which define the different formatting aspects of what a theme
+// defines.
+type xlsxThemeElements struct {
+	ClrScheme  xlsxClrScheme  `xml:"clrScheme"`
+	FontScheme xlsxFontScheme `xml:"fontScheme"`
+	FmtScheme  xlsxFmtScheme  `xml:"fmtScheme"`
+}
+
+// xlsxClrScheme element specifies the theme color, stored in the document's
+// Theme part to which the value of this theme color shall be mapped. This
+// mapping enables multiple theme colors to be chained together.
+type xlsxClrScheme struct {
+	Name     string            `xml:"name,attr"`
+	Children []xlsxClrSchemeEl `xml:",any"`
+}
+
+// xlsxFontScheme element defines the font scheme within the theme. The font
+// scheme consists of a pair of major and minor fonts for which to use in a
+// document. The major font corresponds well with the heading areas of a
+// document, and the minor font corresponds well with the normal text or
+// paragraph areas.
+type xlsxFontScheme struct {
+	Name      string        `xml:"name,attr"`
+	MajorFont xlsxMajorFont `xml:"majorFont"`
+	MinorFont xlsxMinorFont `xml:"minorFont"`
+	ExtLst    *xlsxExtLst   `xml:"extLst"`
+}
+
+// xlsxMajorFont element defines the set of major fonts which are to be used
+// under different languages or locals.
+type xlsxMajorFont struct {
+	Children []xlsxFontSchemeEl `xml:",any"`
+}
+
+// xlsxMinorFont element defines the set of minor fonts that are to be used
+// under different languages or locals.
+type xlsxMinorFont struct {
+	Children []xlsxFontSchemeEl `xml:",any"`
+}
+
+// xlsxFmtScheme element contains the background fill styles, effect styles,
+// fill styles, and line styles which define the style matrix for a theme. The
+// style matrix consists of subtle, moderate, and intense fills, lines, and
+// effects. The background fills are not generally thought of to directly be
+// associated with the matrix, but do play a role in the style of the overall
+// document. Usually, a given object chooses a single line style, a single
+// fill style, and a single effect style in order to define the overall final
+// look of the object.
+type xlsxFmtScheme struct {
+	Name           string             `xml:"name,attr"`
+	FillStyleLst   xlsxFillStyleLst   `xml:"fillStyleLst"`
+	LnStyleLst     xlsxLnStyleLst     `xml:"lnStyleLst"`
+	EffectStyleLst xlsxEffectStyleLst `xml:"effectStyleLst"`
+	BgFillStyleLst xlsxBgFillStyleLst `xml:"bgFillStyleLst"`
+}
+
+// xlsxFillStyleLst element defines a set of three fill styles that are used
+// within a theme. The three fill styles are arranged in order from subtle to
+// moderate to intense.
+type xlsxFillStyleLst struct {
+	FillStyleLst string `xml:",innerxml"`
+}
+
+// xlsxLnStyleLst element defines a list of three line styles for use within a
+// theme. The three line styles are arranged in order from subtle to moderate
+// to intense versions of lines. This list makes up part of the style matrix.
+type xlsxLnStyleLst struct {
+	LnStyleLst string `xml:",innerxml"`
+}
+
+// xlsxEffectStyleLst element defines a set of three effect styles that create
+// the effect style list for a theme. The effect styles are arranged in order
+// of subtle to moderate to intense.
+type xlsxEffectStyleLst struct {
+	EffectStyleLst string `xml:",innerxml"`
+}
+
+// xlsxBgFillStyleLst  element defines a list of background fills that are
+// used within a theme. The background fills consist of three fills, arranged
+// in order from subtle to moderate to intense.
+type xlsxBgFillStyleLst struct {
+	BgFillStyleLst string `xml:",innerxml"`
+}
+
+// xlsxClrScheme maps to children of the clrScheme element in the namespace
+// http://schemas.openxmlformats.org/drawingml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxClrSchemeEl struct {
+	XMLName xml.Name
+	SysClr  *xlsxSysClr    `xml:"sysClr"`
+	SrgbClr *attrValString `xml:"srgbClr"`
+}
+
+// xlsxFontSchemeEl directly maps the major and minor font of the style's font
+// scheme.
+type xlsxFontSchemeEl struct {
+	XMLName     xml.Name
+	Script      string `xml:"script,attr,omitempty"`
+	Typeface    string `xml:"typeface,attr"`
+	Panose      string `xml:"panose,attr,omitempty"`
+	PitchFamily string `xml:"pitchFamily,attr,omitempty"`
+	Charset     string `xml:"charset,attr,omitempty"`
+}
+
+// xlsxSysClr element specifies a color bound to predefined operating system
+// elements.
+type xlsxSysClr struct {
+	Val     string `xml:"val,attr"`
+	LastClr string `xml:"lastClr,attr"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlWorkbook.go

@@ -0,0 +1,282 @@
+package excelize
+
+import "encoding/xml"
+
+// xmlxWorkbookRels contains xmlxWorkbookRelations which maps sheet id and sheet XML.
+type xlsxWorkbookRels struct {
+	XMLName       xml.Name               `xml:"http://schemas.openxmlformats.org/package/2006/relationships Relationships"`
+	Relationships []xlsxWorkbookRelation `xml:"Relationship"`
+}
+
+// xmlxWorkbookRelation maps sheet id and xl/worksheets/_rels/sheet%d.xml.rels
+type xlsxWorkbookRelation struct {
+	ID         string `xml:"Id,attr"`
+	Target     string `xml:",attr"`
+	Type       string `xml:",attr"`
+	TargetMode string `xml:",attr,omitempty"`
+}
+
+// xlsxWorkbook directly maps the workbook element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxWorkbook struct {
+	XMLName             xml.Name                 `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main workbook"`
+	FileVersion         *xlsxFileVersion         `xml:"fileVersion"`
+	WorkbookPr          *xlsxWorkbookPr          `xml:"workbookPr"`
+	WorkbookProtection  *xlsxWorkbookProtection  `xml:"workbookProtection"`
+	BookViews           xlsxBookViews            `xml:"bookViews"`
+	Sheets              xlsxSheets               `xml:"sheets"`
+	ExternalReferences  *xlsxExternalReferences  `xml:"externalReferences"`
+	DefinedNames        *xlsxDefinedNames        `xml:"definedNames"`
+	CalcPr              *xlsxCalcPr              `xml:"calcPr"`
+	CustomWorkbookViews *xlsxCustomWorkbookViews `xml:"customWorkbookViews"`
+	PivotCaches         *xlsxPivotCaches         `xml:"pivotCaches"`
+	ExtLst              *xlsxExtLst              `xml:"extLst"`
+	FileRecoveryPr      *xlsxFileRecoveryPr      `xml:"fileRecoveryPr"`
+}
+
+// xlsxFileRecoveryPr maps sheet recovery information. This element defines
+// properties that track the state of the workbook file, such as whether the
+// file was saved during a crash, or whether it should be opened in auto-recover
+// mode.
+type xlsxFileRecoveryPr struct {
+	AutoRecover     bool `xml:"autoRecover,attr,omitempty"`
+	CrashSave       bool `xml:"crashSave,attr,omitempty"`
+	DataExtractLoad bool `xml:"dataExtractLoad,attr,omitempty"`
+	RepairLoad      bool `xml:"repairLoad,attr,omitempty"`
+}
+
+// xlsxWorkbookProtection directly maps the workbookProtection element. This
+// element specifies options for protecting data in the workbook. Applications
+// might use workbook protection to prevent anyone from accidentally changing,
+// moving, or deleting important data. This protection can be ignored by
+// applications which choose not to support this optional protection mechanism.
+// When a password is to be hashed and stored in this element, it shall be
+// hashed as defined below, starting from a UTF-16LE encoded string value. If
+// there is a leading BOM character (U+FEFF) in the encoded password it is
+// removed before hash calculation.
+type xlsxWorkbookProtection struct {
+	LockRevision           bool   `xml:"lockRevision,attr,omitempty"`
+	LockStructure          bool   `xml:"lockStructure,attr,omitempty"`
+	LockWindows            bool   `xml:"lockWindows,attr,omitempty"`
+	RevisionsAlgorithmName string `xml:"revisionsAlgorithmName,attr,omitempty"`
+	RevisionsHashValue     string `xml:"revisionsHashValue,attr,omitempty"`
+	RevisionsSaltValue     string `xml:"revisionsSaltValue,attr,omitempty"`
+	RevisionsSpinCount     int    `xml:"revisionsSpinCount,attr,omitempty"`
+	WorkbookAlgorithmName  string `xml:"workbookAlgorithmName,attr,omitempty"`
+	WorkbookHashValue      string `xml:"workbookHashValue,attr,omitempty"`
+	WorkbookSaltValue      string `xml:"workbookSaltValue,attr,omitempty"`
+	WorkbookSpinCount      int    `xml:"workbookSpinCount,attr,omitempty"`
+}
+
+// xlsxFileVersion directly maps the fileVersion element. This element defines
+// properties that track which version of the application accessed the data and
+// source code contained in the file.
+type xlsxFileVersion struct {
+	AppName      string `xml:"appName,attr,omitempty"`
+	CodeName     string `xml:"codeName,attr,omitempty"`
+	LastEdited   string `xml:"lastEdited,attr,omitempty"`
+	LowestEdited string `xml:"lowestEdited,attr,omitempty"`
+	RupBuild     string `xml:"rupBuild,attr,omitempty"`
+}
+
+// xlsxWorkbookPr directly maps the workbookPr element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main This element
+// defines a collection of workbook properties.
+type xlsxWorkbookPr struct {
+	AllowRefreshQuery          bool   `xml:"allowRefreshQuery,attr,omitempty"`
+	AutoCompressPictures       bool   `xml:"autoCompressPictures,attr,omitempty"`
+	BackupFile                 bool   `xml:"backupFile,attr,omitempty"`
+	CheckCompatibility         bool   `xml:"checkCompatibility,attr,omitempty"`
+	CodeName                   string `xml:"codeName,attr,omitempty"`
+	Date1904                   bool   `xml:"date1904,attr,omitempty"`
+	DefaultThemeVersion        string `xml:"defaultThemeVersion,attr,omitempty"`
+	FilterPrivacy              bool   `xml:"filterPrivacy,attr,omitempty"`
+	HidePivotFieldList         bool   `xml:"hidePivotFieldList,attr,omitempty"`
+	PromptedSolutions          bool   `xml:"promptedSolutions,attr,omitempty"`
+	PublishItems               bool   `xml:"publishItems,attr,omitempty"`
+	RefreshAllConnections      bool   `xml:"refreshAllConnections,attr,omitempty"`
+	SaveExternalLinkValues     bool   `xml:"saveExternalLinkValues,attr,omitempty"`
+	ShowBorderUnselectedTables bool   `xml:"showBorderUnselectedTables,attr,omitempty"`
+	ShowInkAnnotation          bool   `xml:"showInkAnnotation,attr,omitempty"`
+	ShowObjects                string `xml:"showObjects,attr,omitempty"`
+	ShowPivotChartFilter       bool   `xml:"showPivotChartFilter,attr,omitempty"`
+	UpdateLinks                string `xml:"updateLinks,attr,omitempty"`
+}
+
+// xlsxBookViews directly maps the bookViews element. This element specifies the
+// collection of workbook views of the enclosing workbook. Each view can specify
+// a window position, filter options, and other configurations. There is no
+// limit on the number of workbook views that can be defined for a workbook.
+type xlsxBookViews struct {
+	WorkBookView []xlsxWorkBookView `xml:"workbookView"`
+}
+
+// xlsxWorkBookView directly maps the workbookView element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main This element
+// specifies a single Workbook view.
+type xlsxWorkBookView struct {
+	ActiveTab              int    `xml:"activeTab,attr,omitempty"`
+	AutoFilterDateGrouping bool   `xml:"autoFilterDateGrouping,attr,omitempty"`
+	FirstSheet             int    `xml:"firstSheet,attr,omitempty"`
+	Minimized              bool   `xml:"minimized,attr,omitempty"`
+	ShowHorizontalScroll   bool   `xml:"showHorizontalScroll,attr,omitempty"`
+	ShowSheetTabs          bool   `xml:"showSheetTabs,attr,omitempty"`
+	ShowVerticalScroll     bool   `xml:"showVerticalScroll,attr,omitempty"`
+	TabRatio               int    `xml:"tabRatio,attr,omitempty"`
+	Visibility             string `xml:"visibility,attr,omitempty"`
+	WindowHeight           int    `xml:"windowHeight,attr,omitempty"`
+	WindowWidth            int    `xml:"windowWidth,attr,omitempty"`
+	XWindow                string `xml:"xWindow,attr,omitempty"`
+	YWindow                string `xml:"yWindow,attr,omitempty"`
+}
+
+// xlsxSheets directly maps the sheets element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main.
+type xlsxSheets struct {
+	Sheet []xlsxSheet `xml:"sheet"`
+}
+
+// xlsxSheet directly maps the sheet element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxSheet struct {
+	Name    string `xml:"name,attr,omitempty"`
+	SheetID string `xml:"sheetId,attr,omitempty"`
+	ID      string `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+	State   string `xml:"state,attr,omitempty"`
+}
+
+// xlsxExternalReferences directly maps the externalReferences element of the
+// external workbook references part.
+type xlsxExternalReferences struct {
+	ExternalReference []xlsxExternalReference `xml:"externalReference"`
+}
+
+// xlsxExternalReference directly maps the externalReference element of the
+// external workbook references part.
+type xlsxExternalReference struct {
+	RID string `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+}
+
+// xlsxPivotCaches element enumerates pivot cache definition parts used by pivot
+// tables and formulas in this workbook.
+type xlsxPivotCaches struct {
+	PivotCache []xlsxPivotCache `xml:"pivotCache"`
+}
+
+// xlsxPivotCache directly maps the pivotCache element.
+type xlsxPivotCache struct {
+	CacheID int    `xml:"cacheId,attr,omitempty"`
+	RID     string `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+}
+
+// extLst element provides a convention for extending spreadsheetML in
+// predefined locations. The locations shall be denoted with the extLst element,
+// and are called extension lists. Extension list locations within the markup
+// document are specified in the markup specification and can be used to store
+// extensions to the markup specification, whether those are future version
+// extensions of the markup specification or are private extensions implemented
+// independently from the markup specification. Markup within an extension might
+// not be understood by a consumer.
+type xlsxExtLst struct {
+	Ext string `xml:",innerxml"`
+}
+
+// xlsxDefinedNames directly maps the definedNames element. This element defines
+// the collection of defined names for this workbook. Defined names are
+// descriptive names to represent cells, ranges of cells, formulas, or constant
+// values. Defined names can be used to represent a range on any worksheet.
+type xlsxDefinedNames struct {
+	DefinedName []xlsxDefinedName `xml:"definedName"`
+}
+
+// xlsxDefinedName directly maps the definedName element from the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main This element
+// defines a defined name within this workbook. A defined name is descriptive
+// text that is used to represents a cell, range of cells, formula, or constant
+// value. For a descriptions of the attributes see https://msdn.microsoft.com/en-us/library/office/documentformat.openxml.spreadsheet.definedname.aspx
+type xlsxDefinedName struct {
+	Comment           string `xml:"comment,attr,omitempty"`
+	CustomMenu        string `xml:"customMenu,attr,omitempty"`
+	Description       string `xml:"description,attr,omitempty"`
+	Function          bool   `xml:"function,attr,omitempty"`
+	FunctionGroupID   int    `xml:"functionGroupId,attr,omitempty"`
+	Help              string `xml:"help,attr,omitempty"`
+	Hidden            bool   `xml:"hidden,attr,omitempty"`
+	LocalSheetID      *int   `xml:"localSheetId,attr"`
+	Name              string `xml:"name,attr,omitempty"`
+	PublishToServer   bool   `xml:"publishToServer,attr,omitempty"`
+	ShortcutKey       string `xml:"shortcutKey,attr,omitempty"`
+	StatusBar         string `xml:"statusBar,attr,omitempty"`
+	VbProcedure       bool   `xml:"vbProcedure,attr,omitempty"`
+	WorkbookParameter bool   `xml:"workbookParameter,attr,omitempty"`
+	Xlm               bool   `xml:"xml,attr,omitempty"`
+	Data              string `xml:",chardata"`
+}
+
+// xlsxCalcPr directly maps the calcPr element. This element defines the
+// collection of properties the application uses to record calculation status
+// and details. Calculation is the process of computing formulas and then
+// displaying the results as values in the cells that contain the formulas.
+type xlsxCalcPr struct {
+	CalcCompleted         bool    `xml:"calcCompleted,attr,omitempty"`
+	CalcID                string  `xml:"calcId,attr,omitempty"`
+	CalcMode              string  `xml:"calcMode,attr,omitempty"`
+	CalcOnSave            bool    `xml:"calcOnSave,attr,omitempty"`
+	ConcurrentCalc        *bool   `xml:"concurrentCalc,attr"`
+	ConcurrentManualCount int     `xml:"concurrentManualCount,attr,omitempty"`
+	ForceFullCalc         bool    `xml:"forceFullCalc,attr,omitempty"`
+	FullCalcOnLoad        bool    `xml:"fullCalcOnLoad,attr,omitempty"`
+	FullPrecision         bool    `xml:"fullPrecision,attr,omitempty"`
+	Iterate               bool    `xml:"iterate,attr,omitempty"`
+	IterateCount          int     `xml:"iterateCount,attr,omitempty"`
+	IterateDelta          float64 `xml:"iterateDelta,attr,omitempty"`
+	RefMode               string  `xml:"refMode,attr,omitempty"`
+}
+
+// xlsxCustomWorkbookViews defines the collection of custom workbook views that
+// are defined for this workbook. A customWorkbookView is similar in concept to
+// a workbookView in that its attributes contain settings related to the way
+// that the workbook should be displayed on a screen by a spreadsheet
+// application.
+type xlsxCustomWorkbookViews struct {
+	CustomWorkbookView []xlsxCustomWorkbookView `xml:"customWorkbookView"`
+}
+
+// xlsxCustomWorkbookView directly maps the customWorkbookView element. This
+// element specifies a single custom workbook view. A custom workbook view
+// consists of a set of display and print settings that you can name and apply
+// to a workbook. You can create more than one custom workbook view of the same
+// workbook. Custom Workbook Views are not required in order to construct a
+// valid SpreadsheetML document, and are not necessary if the document is never
+// displayed by a spreadsheet application, or if the spreadsheet application has
+// a fixed display for workbooks. However, if a spreadsheet application chooses
+// to implement configurable display modes, the customWorkbookView element
+// should be used to persist the settings for those display modes.
+type xlsxCustomWorkbookView struct {
+	ActiveSheetID        *int    `xml:"activeSheetId,attr"`
+	AutoUpdate           *bool   `xml:"autoUpdate,attr"`
+	ChangesSavedWin      *bool   `xml:"changesSavedWin,attr"`
+	GUID                 *string `xml:"guid,attr"`
+	IncludeHiddenRowCol  *bool   `xml:"includeHiddenRowCol,attr"`
+	IncludePrintSettings *bool   `xml:"includePrintSettings,attr"`
+	Maximized            *bool   `xml:"maximized,attr"`
+	MergeInterval        int     `xml:"mergeInterval,attr"`
+	Minimized            *bool   `xml:"minimized,attr"`
+	Name                 *string `xml:"name,attr"`
+	OnlySync             *bool   `xml:"onlySync,attr"`
+	PersonalView         *bool   `xml:"personalView,attr"`
+	ShowComments         *string `xml:"showComments,attr"`
+	ShowFormulaBar       *bool   `xml:"showFormulaBar,attr"`
+	ShowHorizontalScroll *bool   `xml:"showHorizontalScroll,attr"`
+	ShowObjects          *string `xml:"showObjects,attr"`
+	ShowSheetTabs        *bool   `xml:"showSheetTabs,attr"`
+	ShowStatusbar        *bool   `xml:"showStatusbar,attr"`
+	ShowVerticalScroll   *bool   `xml:"showVerticalScroll,attr"`
+	TabRatio             *int    `xml:"tabRatio,attr"`
+	WindowHeight         *int    `xml:"windowHeight,attr"`
+	WindowWidth          *int    `xml:"windowWidth,attr"`
+	XWindow              *int    `xml:"xWindow,attr"`
+	YWindow              *int    `xml:"yWindow,attr"`
+}

vendor/github.com/360EntSecGroup-Skylar/excelize/xmlWorksheet.go

@@ -0,0 +1,573 @@
+package excelize
+
+import "encoding/xml"
+
+// xlsxWorksheet directly maps the worksheet element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxWorksheet struct {
+	XMLName               xml.Name                     `xml:"http://schemas.openxmlformats.org/spreadsheetml/2006/main worksheet"`
+	SheetPr               *xlsxSheetPr                 `xml:"sheetPr"`
+	Dimension             xlsxDimension                `xml:"dimension"`
+	SheetViews            xlsxSheetViews               `xml:"sheetViews,omitempty"`
+	SheetFormatPr         *xlsxSheetFormatPr           `xml:"sheetFormatPr"`
+	Cols                  *xlsxCols                    `xml:"cols,omitempty"`
+	SheetData             xlsxSheetData                `xml:"sheetData"`
+	SheetProtection       *xlsxSheetProtection         `xml:"sheetProtection"`
+	AutoFilter            *xlsxAutoFilter              `xml:"autoFilter"`
+	MergeCells            *xlsxMergeCells              `xml:"mergeCells"`
+	PhoneticPr            *xlsxPhoneticPr              `xml:"phoneticPr"`
+	ConditionalFormatting []*xlsxConditionalFormatting `xml:"conditionalFormatting"`
+	DataValidations       *xlsxDataValidations         `xml:"dataValidations"`
+	Hyperlinks            *xlsxHyperlinks              `xml:"hyperlinks"`
+	PrintOptions          *xlsxPrintOptions            `xml:"printOptions"`
+	PageMargins           *xlsxPageMargins             `xml:"pageMargins"`
+	PageSetUp             *xlsxPageSetUp               `xml:"pageSetup"`
+	HeaderFooter          *xlsxHeaderFooter            `xml:"headerFooter"`
+	Drawing               *xlsxDrawing                 `xml:"drawing"`
+	LegacyDrawing         *xlsxLegacyDrawing           `xml:"legacyDrawing"`
+	Picture               *xlsxPicture                 `xml:"picture"`
+	TableParts            *xlsxTableParts              `xml:"tableParts"`
+	ExtLst                *xlsxExtLst                  `xml:"extLst"`
+}
+
+// xlsxDrawing change r:id to rid in the namespace.
+type xlsxDrawing struct {
+	RID string `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+}
+
+// xlsxHeaderFooter directly maps the headerFooter element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - When printed or
+// viewed in page layout view (§18.18.69), each page of a worksheet can have a
+// page header, a page footer, or both. The headers and footers on odd-numbered
+// pages can differ from those on even-numbered pages, and the headers and
+// footers on the first page can differ from those on odd- and even-numbered
+// pages. In the latter case, the first page is not considered an odd page.
+type xlsxHeaderFooter struct {
+	DifferentFirst   bool             `xml:"differentFirst,attr,omitempty"`
+	DifferentOddEven bool             `xml:"differentOddEven,attr,omitempty"`
+	OddHeader        []*xlsxOddHeader `xml:"oddHeader"`
+	OddFooter        []*xlsxOddFooter `xml:"oddFooter"`
+}
+
+// xlsxOddHeader directly maps the oddHeader element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxOddHeader struct {
+	Content string `xml:",chardata"`
+}
+
+// xlsxOddFooter directly maps the oddFooter element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxOddFooter struct {
+	Content string `xml:",chardata"`
+}
+
+// xlsxPageSetUp directly maps the pageSetup element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - Page setup
+// settings for the worksheet.
+type xlsxPageSetUp struct {
+	BlackAndWhite      bool    `xml:"blackAndWhite,attr,omitempty"`
+	CellComments       string  `xml:"cellComments,attr,omitempty"`
+	Copies             int     `xml:"copies,attr,omitempty"`
+	Draft              bool    `xml:"draft,attr,omitempty"`
+	Errors             string  `xml:"errors,attr,omitempty"`
+	FirstPageNumber    int     `xml:"firstPageNumber,attr,omitempty"`
+	FitToHeight        *int    `xml:"fitToHeight,attr"`
+	FitToWidth         int     `xml:"fitToWidth,attr,omitempty"`
+	HorizontalDPI      float32 `xml:"horizontalDpi,attr,omitempty"`
+	RID                string  `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+	Orientation        string  `xml:"orientation,attr,omitempty"`
+	PageOrder          string  `xml:"pageOrder,attr,omitempty"`
+	PaperHeight        string  `xml:"paperHeight,attr,omitempty"`
+	PaperSize          string  `xml:"paperSize,attr,omitempty"`
+	PaperWidth         string  `xml:"paperWidth,attr,omitempty"`
+	Scale              int     `xml:"scale,attr,omitempty"`
+	UseFirstPageNumber bool    `xml:"useFirstPageNumber,attr,omitempty"`
+	UsePrinterDefaults bool    `xml:"usePrinterDefaults,attr,omitempty"`
+	VerticalDPI        float32 `xml:"verticalDpi,attr,omitempty"`
+}
+
+// xlsxPrintOptions directly maps the printOptions element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - Print options for
+// the sheet. Printer-specific settings are stored separately in the Printer
+// Settings part.
+type xlsxPrintOptions struct {
+	GridLines          bool `xml:"gridLines,attr,omitempty"`
+	GridLinesSet       bool `xml:"gridLinesSet,attr,omitempty"`
+	Headings           bool `xml:"headings,attr,omitempty"`
+	HorizontalCentered bool `xml:"horizontalCentered,attr,omitempty"`
+	VerticalCentered   bool `xml:"verticalCentered,attr,omitempty"`
+}
+
+// xlsxPageMargins directly maps the pageMargins element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - Page margins for
+// a sheet or a custom sheet view.
+type xlsxPageMargins struct {
+	Bottom float64 `xml:"bottom,attr"`
+	Footer float64 `xml:"footer,attr"`
+	Header float64 `xml:"header,attr"`
+	Left   float64 `xml:"left,attr"`
+	Right  float64 `xml:"right,attr"`
+	Top    float64 `xml:"top,attr"`
+}
+
+// xlsxSheetFormatPr directly maps the sheetFormatPr element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main. This element
+// specifies the sheet formatting properties.
+type xlsxSheetFormatPr struct {
+	BaseColWidth     uint8   `xml:"baseColWidth,attr,omitempty"`
+	DefaultColWidth  float64 `xml:"defaultColWidth,attr,omitempty"`
+	DefaultRowHeight float64 `xml:"defaultRowHeight,attr"`
+	CustomHeight     bool    `xml:"customHeight,attr,omitempty"`
+	ZeroHeight       bool    `xml:"zeroHeight,attr,omitempty"`
+	ThickTop         bool    `xml:"thickTop,attr,omitempty"`
+	ThickBottom      bool    `xml:"thickBottom,attr,omitempty"`
+	OutlineLevelRow  uint8   `xml:"outlineLevelRow,attr,omitempty"`
+	OutlineLevelCol  uint8   `xml:"outlineLevelCol,attr,omitempty"`
+}
+
+// xlsxSheetViews directly maps the sheetViews element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - Worksheet views
+// collection.
+type xlsxSheetViews struct {
+	SheetView []xlsxSheetView `xml:"sheetView"`
+}
+
+// xlsxSheetView directly maps the sheetView element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need. A single sheet
+// view definition. When more than one sheet view is defined in the file, it
+// means that when opening the workbook, each sheet view corresponds to a
+// separate window within the spreadsheet application, where each window is
+// showing the particular sheet containing the same workbookViewId value, the
+// last sheetView definition is loaded, and the others are discarded. When
+// multiple windows are viewing the same sheet, multiple sheetView elements
+// (with corresponding workbookView entries) are saved.
+// See https://msdn.microsoft.com/en-us/library/office/documentformat.openxml.spreadsheet.sheetview.aspx
+type xlsxSheetView struct {
+	WindowProtection         bool             `xml:"windowProtection,attr,omitempty"`
+	ShowFormulas             bool             `xml:"showFormulas,attr,omitempty"`
+	ShowGridLines            *bool            `xml:"showGridLines,attr"`
+	ShowRowColHeaders        *bool            `xml:"showRowColHeaders,attr"`
+	ShowZeros                bool             `xml:"showZeros,attr,omitempty"`
+	RightToLeft              bool             `xml:"rightToLeft,attr,omitempty"`
+	TabSelected              bool             `xml:"tabSelected,attr,omitempty"`
+	ShowWhiteSpace           *bool            `xml:"showWhiteSpace,attr"`
+	ShowOutlineSymbols       bool             `xml:"showOutlineSymbols,attr,omitempty"`
+	DefaultGridColor         *bool            `xml:"defaultGridColor,attr"`
+	View                     string           `xml:"view,attr,omitempty"`
+	TopLeftCell              string           `xml:"topLeftCell,attr,omitempty"`
+	ColorID                  int              `xml:"colorId,attr,omitempty"`
+	ZoomScale                float64          `xml:"zoomScale,attr,omitempty"`
+	ZoomScaleNormal          float64          `xml:"zoomScaleNormal,attr,omitempty"`
+	ZoomScalePageLayoutView  float64          `xml:"zoomScalePageLayoutView,attr,omitempty"`
+	ZoomScaleSheetLayoutView float64          `xml:"zoomScaleSheetLayoutView,attr,omitempty"`
+	WorkbookViewID           int              `xml:"workbookViewId,attr"`
+	Pane                     *xlsxPane        `xml:"pane,omitempty"`
+	Selection                []*xlsxSelection `xml:"selection"`
+}
+
+// xlsxSelection directly maps the selection element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - Worksheet view
+// selection.
+type xlsxSelection struct {
+	ActiveCell   string `xml:"activeCell,attr,omitempty"`
+	ActiveCellID *int   `xml:"activeCellId,attr"`
+	Pane         string `xml:"pane,attr,omitempty"`
+	SQRef        string `xml:"sqref,attr,omitempty"`
+}
+
+// xlsxSelection directly maps the selection element. Worksheet view pane.
+type xlsxPane struct {
+	ActivePane  string  `xml:"activePane,attr,omitempty"`
+	State       string  `xml:"state,attr,omitempty"` // Either "split" or "frozen"
+	TopLeftCell string  `xml:"topLeftCell,attr,omitempty"`
+	XSplit      float64 `xml:"xSplit,attr,omitempty"`
+	YSplit      float64 `xml:"ySplit,attr,omitempty"`
+}
+
+// xlsxSheetPr directly maps the sheetPr element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - Sheet-level
+// properties.
+type xlsxSheetPr struct {
+	XMLName                           xml.Name         `xml:"sheetPr"`
+	CodeName                          string           `xml:"codeName,attr,omitempty"`
+	EnableFormatConditionsCalculation *bool            `xml:"enableFormatConditionsCalculation,attr"`
+	FilterMode                        bool             `xml:"filterMode,attr,omitempty"`
+	Published                         *bool            `xml:"published,attr"`
+	SyncHorizontal                    bool             `xml:"syncHorizontal,attr,omitempty"`
+	SyncVertical                      bool             `xml:"syncVertical,attr,omitempty"`
+	TransitionEntry                   bool             `xml:"transitionEntry,attr,omitempty"`
+	TabColor                          *xlsxTabColor    `xml:"tabColor,omitempty"`
+	PageSetUpPr                       *xlsxPageSetUpPr `xml:"pageSetUpPr,omitempty"`
+}
+
+// xlsxPageSetUpPr directly maps the pageSetupPr element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - Page setup
+// properties of the worksheet.
+type xlsxPageSetUpPr struct {
+	AutoPageBreaks bool `xml:"autoPageBreaks,attr,omitempty"`
+	FitToPage      bool `xml:"fitToPage,attr,omitempty"` // Flag indicating whether the Fit to Page print option is enabled.
+}
+
+// xlsxTabColor directly maps the tabColor element in the namespace currently I
+// have not checked it for completeness - it does as much as I need.
+type xlsxTabColor struct {
+	Theme int     `xml:"theme,attr,omitempty"`
+	Tint  float64 `xml:"tint,attr,omitempty"`
+}
+
+// xlsxCols directly maps the cols element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxCols struct {
+	Col []xlsxCol `xml:"col"`
+}
+
+// xlsxCol directly maps the col (Column Width & Formatting). Defines column
+// width and column formatting for one or more columns of the worksheet.
+type xlsxCol struct {
+	BestFit      bool    `xml:"bestFit,attr,omitempty"`
+	Collapsed    bool    `xml:"collapsed,attr"`
+	CustomWidth  bool    `xml:"customWidth,attr,omitempty"`
+	Hidden       bool    `xml:"hidden,attr"`
+	Max          int     `xml:"max,attr"`
+	Min          int     `xml:"min,attr"`
+	OutlineLevel uint8   `xml:"outlineLevel,attr,omitempty"`
+	Phonetic     bool    `xml:"phonetic,attr,omitempty"`
+	Style        int     `xml:"style,attr"`
+	Width        float64 `xml:"width,attr"`
+}
+
+// xlsxDimension directly maps the dimension element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - This element
+// specifies the used range of the worksheet. It specifies the row and column
+// bounds of used cells in the worksheet. This is optional and is not required.
+// Used cells include cells with formulas, text content, and cell formatting.
+// When an entire column is formatted, only the first cell in that column is
+// considered used.
+type xlsxDimension struct {
+	Ref string `xml:"ref,attr"`
+}
+
+// xlsxSheetData directly maps the sheetData element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxSheetData struct {
+	XMLName xml.Name  `xml:"sheetData"`
+	Row     []xlsxRow `xml:"row"`
+}
+
+// xlsxRow directly maps the row element. The element expresses information
+// about an entire row of a worksheet, and contains all cell definitions for a
+// particular row in the worksheet.
+type xlsxRow struct {
+	Collapsed    bool    `xml:"collapsed,attr,omitempty"`
+	CustomFormat bool    `xml:"customFormat,attr,omitempty"`
+	CustomHeight bool    `xml:"customHeight,attr,omitempty"`
+	Hidden       bool    `xml:"hidden,attr,omitempty"`
+	Ht           float64 `xml:"ht,attr,omitempty"`
+	OutlineLevel uint8   `xml:"outlineLevel,attr,omitempty"`
+	Ph           bool    `xml:"ph,attr,omitempty"`
+	R            int     `xml:"r,attr,omitempty"`
+	S            int     `xml:"s,attr,omitempty"`
+	Spans        string  `xml:"spans,attr,omitempty"`
+	ThickBot     bool    `xml:"thickBot,attr,omitempty"`
+	ThickTop     bool    `xml:"thickTop,attr,omitempty"`
+	C            []xlsxC `xml:"c"`
+}
+
+// xlsxMergeCell directly maps the mergeCell element. A single merged cell.
+type xlsxMergeCell struct {
+	Ref string `xml:"ref,attr,omitempty"`
+}
+
+// xlsxMergeCells directly maps the mergeCells element. This collection
+// expresses all the merged cells in the sheet.
+type xlsxMergeCells struct {
+	Count int              `xml:"count,attr,omitempty"`
+	Cells []*xlsxMergeCell `xml:"mergeCell,omitempty"`
+}
+
+// xlsxDataValidations expresses all data validation information for cells in a
+// sheet which have data validation features applied.
+type xlsxDataValidations struct {
+	Count          int    `xml:"count,attr,omitempty"`
+	DisablePrompts bool   `xml:"disablePrompts,attr,omitempty"`
+	XWindow        int    `xml:"xWindow,attr,omitempty"`
+	YWindow        int    `xml:"yWindow,attr,omitempty"`
+	DataValidation string `xml:",innerxml"`
+}
+
+// xlsxC directly maps the c element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+//
+// This simple type is restricted to the values listed in the following table:
+//
+//      Enumeration Value         | Description
+//     ---------------------------+---------------------------------
+//      b (Boolean)               | Cell containing a boolean.
+//      d (Date)                  | Cell contains a date in the ISO 8601 format.
+//      e (Error)                 | Cell containing an error.
+//      inlineStr (Inline String) | Cell containing an (inline) rich string, i.e., one not in the shared string table. If this cell type is used, then the cell value is in the is element rather than the v element in the cell (c element).
+//      n (Number)                | Cell containing a number.
+//      s (Shared String)         | Cell containing a shared string.
+//      str (String)              | Cell containing a formula string.
+//
+type xlsxC struct {
+	R string `xml:"r,attr"`           // Cell ID, e.g. A1
+	S int    `xml:"s,attr,omitempty"` // Style reference.
+	// Str string `xml:"str,attr,omitempty"` // Style reference.
+	T        string   `xml:"t,attr,omitempty"` // Type.
+	F        *xlsxF   `xml:"f,omitempty"`      // Formula
+	V        string   `xml:"v,omitempty"`      // Value
+	IS       *xlsxIS  `xml:"is"`
+	XMLSpace xml.Attr `xml:"space,attr,omitempty"`
+}
+
+// xlsxIS directly maps the t element. Cell containing an (inline) rich
+// string, i.e., one not in the shared string table. If this cell type is
+// used, then the cell value is in the is element rather than the v element in
+// the cell (c element).
+type xlsxIS struct {
+	T string `xml:"t"`
+}
+
+// xlsxF directly maps the f element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - currently I have
+// not checked it for completeness - it does as much as I need.
+type xlsxF struct {
+	Content string `xml:",chardata"`
+	T       string `xml:"t,attr,omitempty"`   // Formula type
+	Ref     string `xml:"ref,attr,omitempty"` // Shared formula ref
+	Si      string `xml:"si,attr,omitempty"`  // Shared formula index
+}
+
+// xlsxSheetProtection collection expresses the sheet protection options to
+// enforce when the sheet is protected.
+type xlsxSheetProtection struct {
+	AlgorithmName      string `xml:"algorithmName,attr,omitempty"`
+	AutoFilter         int    `xml:"autoFilter,attr,omitempty"`
+	DeleteColumns      int    `xml:"deleteColumns,attr,omitempty"`
+	DeleteRows         int    `xml:"deleteRows,attr,omitempty"`
+	FormatCells        int    `xml:"formatCells,attr,omitempty"`
+	FormatColumns      int    `xml:"formatColumns,attr,omitempty"`
+	FormatRows         int    `xml:"formatRows,attr,omitempty"`
+	HashValue          string `xml:"hashValue,attr,omitempty"`
+	InsertColumns      int    `xml:"insertColumns,attr,omitempty"`
+	InsertHyperlinks   int    `xml:"insertHyperlinks,attr,omitempty"`
+	InsertRows         int    `xml:"insertRows,attr,omitempty"`
+	Objects            int    `xml:"objects,attr,omitempty"`
+	PivotTables        int    `xml:"pivotTables,attr,omitempty"`
+	SaltValue          string `xml:"saltValue,attr,omitempty"`
+	Scenarios          int    `xml:"scenarios,attr,omitempty"`
+	SelectLockedCells  int    `xml:"selectLockedCells,attr,omitempty"`
+	SelectUnlockedCell int    `xml:"selectUnlockedCell,attr,omitempty"`
+	Sheet              int    `xml:"sheet,attr,omitempty"`
+	Sort               int    `xml:"sort,attr,omitempty"`
+	SpinCount          int    `xml:"spinCount,attr,omitempty"`
+}
+
+// xlsxPhoneticPr (Phonetic Properties) represents a collection of phonetic
+// properties that affect the display of phonetic text for this String Item
+// (si). Phonetic text is used to give hints as to the pronunciation of an East
+// Asian language, and the hints are displayed as text within the spreadsheet
+// cells across the top portion of the cell. Since the phonetic hints are text,
+// every phonetic hint is expressed as a phonetic run (rPh), and these
+// properties specify how to display that phonetic run.
+type xlsxPhoneticPr struct {
+	Alignment string `xml:"alignment,attr,omitempty"`
+	FontID    *int   `xml:"fontId,attr"`
+	Type      string `xml:"type,attr,omitempty"`
+}
+
+// A Conditional Format is a format, such as cell shading or font color, that a
+// spreadsheet application can automatically apply to cells if a specified
+// condition is true. This collection expresses conditional formatting rules
+// applied to a particular cell or range.
+type xlsxConditionalFormatting struct {
+	SQRef  string        `xml:"sqref,attr,omitempty"`
+	CfRule []*xlsxCfRule `xml:"cfRule"`
+}
+
+// xlsxCfRule (Conditional Formatting Rule) represents a description of a
+// conditional formatting rule.
+type xlsxCfRule struct {
+	AboveAverage *bool           `xml:"aboveAverage,attr"`
+	Bottom       bool            `xml:"bottom,attr,omitempty"`
+	DxfID        *int            `xml:"dxfId,attr"`
+	EqualAverage bool            `xml:"equalAverage,attr,omitempty"`
+	Operator     string          `xml:"operator,attr,omitempty"`
+	Percent      bool            `xml:"percent,attr,omitempty"`
+	Priority     int             `xml:"priority,attr,omitempty"`
+	Rank         int             `xml:"rank,attr,omitempty"`
+	StdDev       int             `xml:"stdDev,attr,omitempty"`
+	StopIfTrue   bool            `xml:"stopIfTrue,attr,omitempty"`
+	Text         string          `xml:"text,attr,omitempty"`
+	TimePeriod   string          `xml:"timePeriod,attr,omitempty"`
+	Type         string          `xml:"type,attr,omitempty"`
+	Formula      []string        `xml:"formula,omitempty"`
+	ColorScale   *xlsxColorScale `xml:"colorScale"`
+	DataBar      *xlsxDataBar    `xml:"dataBar"`
+	IconSet      *xlsxIconSet    `xml:"iconSet"`
+	ExtLst       *xlsxExtLst     `xml:"extLst"`
+}
+
+// xlsxColorScale (Color Scale) describes a gradated color scale in this
+// conditional formatting rule.
+type xlsxColorScale struct {
+	Cfvo  []*xlsxCfvo  `xml:"cfvo"`
+	Color []*xlsxColor `xml:"color"`
+}
+
+// dataBar (Data Bar) describes a data bar conditional formatting rule.
+type xlsxDataBar struct {
+	MaxLength int          `xml:"maxLength,attr,omitempty"`
+	MinLength int          `xml:"minLength,attr,omitempty"`
+	ShowValue bool         `xml:"showValue,attr,omitempty"`
+	Cfvo      []*xlsxCfvo  `xml:"cfvo"`
+	Color     []*xlsxColor `xml:"color"`
+}
+
+// xlsxIconSet (Icon Set) describes an icon set conditional formatting rule.
+type xlsxIconSet struct {
+	Cfvo      []*xlsxCfvo `xml:"cfvo"`
+	IconSet   string      `xml:"iconSet,attr,omitempty"`
+	ShowValue bool        `xml:"showValue,attr,omitempty"`
+	Percent   bool        `xml:"percent,attr,omitempty"`
+	Reverse   bool        `xml:"reverse,attr,omitempty"`
+}
+
+// cfvo (Conditional Format Value Object) describes the values of the
+// interpolation points in a gradient scale.
+type xlsxCfvo struct {
+	Gte    bool        `xml:"gte,attr,omitempty"`
+	Type   string      `xml:"type,attr,omitempty"`
+	Val    string      `xml:"val,attr"`
+	ExtLst *xlsxExtLst `xml:"extLst"`
+}
+
+// xlsxHyperlinks directly maps the hyperlinks element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - A hyperlink can
+// be stored in a package as a relationship. Hyperlinks shall be identified by
+// containing a target which specifies the destination of the given hyperlink.
+type xlsxHyperlinks struct {
+	Hyperlink []xlsxHyperlink `xml:"hyperlink"`
+}
+
+// xlsxHyperlink directly maps the hyperlink element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main
+type xlsxHyperlink struct {
+	Ref      string `xml:"ref,attr"`
+	Location string `xml:"location,attr,omitempty"`
+	Display  string `xml:"display,attr,omitempty"`
+	RID      string `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+}
+
+// xlsxTableParts directly maps the tableParts element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - The table element
+// has several attributes applied to identify the table and the data range it
+// covers. The table id attribute needs to be unique across all table parts, the
+// same goes for the name and displayName. The displayName has the further
+// restriction that it must be unique across all defined names in the workbook.
+// Later on we will see that you can define names for many elements, such as
+// cells or formulas. The name value is used for the object model in Microsoft
+// Office Excel. The displayName is used for references in formulas. The ref
+// attribute is used to identify the cell range that the table covers. This
+// includes not only the table data, but also the table header containing column
+// names.
+// To add columns to your table you add new tableColumn elements to the
+// tableColumns container. Similar to the shared string table the collection
+// keeps a count attribute identifying the number of columns. Besides the table
+// definition in the table part there is also the need to identify which tables
+// are displayed in the worksheet. The worksheet part has a separate element
+// tableParts to store this information. Each table part is referenced through
+// the relationship ID and again a count of the number of table parts is
+// maintained. The following markup sample is taken from the documents
+// accompanying this book. The sheet data element has been removed to reduce the
+// size of the sample. To reference the table, just add the tableParts element,
+// of course after having created and stored the table part. For example:
+//
+//    <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+//        ...
+//        <tableParts count="1">
+// 		      <tablePart r:id="rId1" />
+//        </tableParts>
+//    </worksheet>
+//
+type xlsxTableParts struct {
+	Count      int              `xml:"count,attr,omitempty"`
+	TableParts []*xlsxTablePart `xml:"tablePart"`
+}
+
+// xlsxTablePart directly maps the tablePart element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main
+type xlsxTablePart struct {
+	RID string `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+}
+
+// xlsxPicture directly maps the picture element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - Background sheet
+// image. For example:
+//
+//    <picture r:id="rId1"/>
+//
+type xlsxPicture struct {
+	RID string `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+}
+
+// xlsxLegacyDrawing directly maps the legacyDrawing element in the namespace
+// http://schemas.openxmlformats.org/spreadsheetml/2006/main - A comment is a
+// rich text note that is attached to, and associated with, a cell, separate
+// from other cell content. Comment content is stored separate from the cell,
+// and is displayed in a drawing object (like a text box) that is separate from,
+// but associated with, a cell. Comments are used as reminders, such as noting
+// how a complex formula works, or to provide feedback to other users. Comments
+// can also be used to explain assumptions made in a formula or to call out
+// something special about the cell.
+type xlsxLegacyDrawing struct {
+	RID string `xml:"http://schemas.openxmlformats.org/officeDocument/2006/relationships id,attr,omitempty"`
+}
+
+// formatPanes directly maps the settings of the panes.
+type formatPanes struct {
+	Freeze      bool   `json:"freeze"`
+	Split       bool   `json:"split"`
+	XSplit      int    `json:"x_split"`
+	YSplit      int    `json:"y_split"`
+	TopLeftCell string `json:"top_left_cell"`
+	ActivePane  string `json:"active_pane"`
+	Panes       []struct {
+		SQRef      string `json:"sqref"`
+		ActiveCell string `json:"active_cell"`
+		Pane       string `json:"pane"`
+	} `json:"panes"`
+}
+
+// formatConditional directly maps the conditional format settings of the cells.
+type formatConditional struct {
+	Type         string `json:"type"`
+	AboveAverage bool   `json:"above_average"`
+	Percent      bool   `json:"percent"`
+	Format       int    `json:"format"`
+	Criteria     string `json:"criteria"`
+	Value        string `json:"value,omitempty"`
+	Minimum      string `json:"minimum,omitempty"`
+	Maximum      string `json:"maximum,omitempty"`
+	MinType      string `json:"min_type,omitempty"`
+	MidType      string `json:"mid_type,omitempty"`
+	MaxType      string `json:"max_type,omitempty"`
+	MinValue     string `json:"min_value,omitempty"`
+	MidValue     string `json:"mid_value,omitempty"`
+	MaxValue     string `json:"max_value,omitempty"`
+	MinColor     string `json:"min_color,omitempty"`
+	MidColor     string `json:"mid_color,omitempty"`
+	MaxColor     string `json:"max_color,omitempty"`
+	MinLength    string `json:"min_length,omitempty"`
+	MaxLength    string `json:"max_length,omitempty"`
+	MultiRange   string `json:"multi_range,omitempty"`
+	BarColor     string `json:"bar_color,omitempty"`
+}

vendor/github.com/AlecAivazis/survey/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "confirm.go",
+        "editor.go",
+        "input.go",
+        "multiline.go",
+        "multiselect.go",
+        "password.go",
+        "select.go",
+        "survey.go",
+        "transform.go",
+        "validate.go",
+    ],
+    data = ["Gopkg.toml"],
+    importpath = "github.com/AlecAivazis/survey",
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//vendor/github.com/kballard/go-shellquote:go_default_library",
+        "//vendor/gopkg.in/AlecAivazis/survey.v1/core:go_default_library",
+        "//vendor/gopkg.in/AlecAivazis/survey.v1/terminal:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/AlecAivazis/survey/CONTRIBUTING.md

@@ -0,0 +1,78 @@
+# Contributing to Survey
+
+🎉🎉 First off, thanks for the interest in contributing to `survey`! 🎉🎉
+
+The following is a set of guidelines to follow when contributing to this package. These are not hard rules, please use common sense and feel free to propose changes to this document in a pull request.
+
+## Table of Contents
+
+1. [Code of Conduct](#code-of-conduct)
+1. [Getting Help](#getting-help)
+1. [Filing a Bug Report](#how-to-file-a-bug-report)
+1. [Suggesting an API change](#suggesting-an-api-change)
+1. [Submitting a Contribution](#submitting-a-contribution)
+1. [Writing and Running Tests](#writing-and-running-tests)
+
+## Code of Conduct
+
+This project and its contibutors are expected to uphold the [Go Community Code of Conduct](https://golang.org/conduct). By participating, you are expected to follow these guidelines.
+
+## Getting help
+
+Feel free to [open up an issue](https://github.com/AlecAivazis/survey/issues/new) on GitHub when asking a question so others will be able to find it. Please remember to tag the issue with the `Question` label so the maintainers can get to your question as soon as possible. If the question is urgent, feel free to reach out to `@AlecAivazis` directly in the gophers slack channel.
+
+## How to file a bug report
+
+Bugs are tracked using the Github Issue tracker. When filing a bug, please remember to label the issue as a `Bug` and answer/provide the following:
+1. What operating system and terminal are you using?
+1. An example that showcases the bug.
+1. What did you expect to see?
+1. What did you see instead?
+
+## Suggesting an API change
+
+If you have an idea, I'm more than happy to discuss it. Please open an issue labeled `Discussion` and we can work through it. In order to maintain some sense of stability, additions to the top-level API are taken just as seriously as changes that break it. Adding stuff is much easier than removing it.
+
+## Submitting a contribution
+
+In order to maintain stability, most features get fully integrated in more than one PR. This allows for more opportunity to think through each API change without amassing large amounts of tech debt and API changes  at once. If your feature can be broken into separate chunks, it will be able to be reviewed much quicker. For example, if the PR that implemented the `Validate` field was submitted in a PR separately from one that included `survey.Required`, it would be able to get merge without having to decide how many different `Validators` we want to provide as part of `survey`'s API.
+
+When submitting a contribution,
+  *  Provide a description of the feature or change
+  *  Reference the ticket addressed by the PR if there is one
+  *  Following community standards, add comments for all exported members so that all necessary information is available on godocs
+  *  Remember to update the project README.md with changes to the high-level API
+  *  Include both positive and negative unit tests (when applicable)
+  *  Contributions with visual ramifications or interaction changes should be accompanied with the appropriate `go-expect` tests. For more information on writing these tests, see [Writing and Running Tests](#writing-and-running-tests)
+
+
+## Writing and running tests
+
+When submitting features, please add as many units tests as necessary to test both positive and negative cases.
+
+Integration tests for survey uses [go-expect](https://github.com/Netflix/go-expect) to expect a match on stdout and respond on stdin. Since `os.Stdout` in a `go test` process is not a TTY, you need a way to interpret terminal / ANSI escape sequences for things like `CursorLocation`. The stdin/stdout handled by `go-expect` is also multiplexed to a [virtual terminal](https://github.com/hinshun/vt10x).
+
+For example, you can extend the tests for Input by specifying the following test case:
+
+```go
+{
+  "Test Input prompt interaction",       // Name of the test.
+  &Input{                                // An implementation of the survey.Prompt interface.
+    Message: "What is your name?",
+  },
+  func(c *expect.Console) {              // An expect procedure. You can expect strings / regexps and
+    c.ExpectString("What is your name?") // write back strings / bytes to its psuedoterminal for survey.
+    c.SendLine("Johnny Appleseed")
+    c.ExpectEOF()                        // Nothing is read from the tty without an expect, and once an
+                                         // expectation is met, no further bytes are read. End your
+                                         // procedure with `c.ExpectEOF()` to read until survey finishes.
+  },
+  "Johnny Appleseed",                    // The expected result.
+}
+```
+
+If you want to write your own `go-expect` test from scratch, you'll need to instantiate a virtual terminal,
+multiplex it into an `*expect.Console`, and hook up its tty with survey's optional stdio. Please see `go-expect`
+[documentation](https://godoc.org/github.com/Netflix/go-expect) for more detail.
+
+

vendor/github.com/AlecAivazis/survey/Gopkg.lock

@@ -0,0 +1,78 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  branch = "master"
+  name = "github.com/Netflix/go-expect"
+  packages = ["."]
+  revision = "c93bf25de8e869da25cf26bcd2932b36141f61ae"
+
+[[projects]]
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/hinshun/vt10x"
+  packages = ["."]
+  revision = "1954e646417484a2a687ea344edade2c2b6523c8"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/kballard/go-shellquote"
+  packages = ["."]
+  revision = "95032a82bc518f77982ea72343cc1ade730072f0"
+
+[[projects]]
+  name = "github.com/kr/pty"
+  packages = ["."]
+  revision = "282ce0e5322c82529687d609ee670fac7c7d917c"
+  version = "v1.1.1"
+
+[[projects]]
+  name = "github.com/mattn/go-colorable"
+  packages = ["."]
+  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
+  version = "v0.0.9"
+
+[[projects]]
+  name = "github.com/mattn/go-isatty"
+  packages = ["."]
+  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
+  version = "v0.0.3"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/mgutz/ansi"
+  packages = ["."]
+  revision = "9520e82c474b0a04dd04f8a40959027271bab992"
+
+[[projects]]
+  name = "github.com/pmezard/go-difflib"
+  packages = ["difflib"]
+  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/stretchr/testify"
+  packages = [
+    "assert",
+    "require"
+  ]
+  revision = "12b6f73e6084dad08a7c6e575284b177ecafbc71"
+  version = "v1.2.1"
+
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/sys"
+  packages = ["unix"]
+  revision = "9527bec2660bd847c050fda93a0f0c6dee0800bb"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  inputs-digest = "371508ebad4798adc38a118f858b5c17a65b58594203548f9feb74cb781dd907"
+  solver-name = "gps-cdcl"
+  solver-version = 1

vendor/github.com/AlecAivazis/survey/Gopkg.toml

@@ -0,0 +1,54 @@
+# Gopkg.toml example
+#
+# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/Netflix/go-expect"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/hinshun/vt10x"
+
+[[constraint]]
+  name = "github.com/mattn/go-isatty"
+  version = "0.0.3"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/mgutz/ansi"
+
+[[constraint]]
+  name = "github.com/stretchr/testify"
+  version = "1.2.1"
+
+[prune]
+  go-tests = true
+  unused-packages = true
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/kballard/go-shellquote"

vendor/github.com/AlecAivazis/survey/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Alec Aivazis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/github.com/AlecAivazis/survey/README.md

@@ -0,0 +1,395 @@
+# Survey
+
+[![Build Status](https://travis-ci.org/AlecAivazis/survey.svg?branch=feature%2Fpretty)](https://travis-ci.org/AlecAivazis/survey)
+[![GoDoc](http://img.shields.io/badge/godoc-reference-5272B4.svg)](https://godoc.org/gopkg.in/AlecAivazis/survey.v1)
+
+A library for building interactive prompts. 
+
+<img width="550" src="https://thumbs.gfycat.com/VillainousGraciousKouprey-size_restricted.gif"/>
+
+```go
+package main
+
+import (
+    "fmt"
+    "gopkg.in/AlecAivazis/survey.v1"
+)
+
+// the questions to ask
+var qs = []*survey.Question{
+    {
+        Name:     "name",
+        Prompt:   &survey.Input{Message: "What is your name?"},
+        Validate: survey.Required,
+        Transform: survey.Title,
+    },
+    {
+        Name: "color",
+        Prompt: &survey.Select{
+            Message: "Choose a color:",
+            Options: []string{"red", "blue", "green"},
+            Default: "red",
+        },
+    },
+    {
+        Name: "age",
+        Prompt:   &survey.Input{Message: "How old are you?"},
+    },
+}
+
+func main() {
+    // the answers will be written to this struct
+    answers := struct {
+        Name          string                  // survey will match the question and field names
+        FavoriteColor string `survey:"color"` // or you can tag fields to match a specific name
+        Age           int                     // if the types don't match exactly, survey will try to convert for you
+    }{}
+
+    // perform the questions
+    err := survey.Ask(qs, &answers)
+    if err != nil {
+        fmt.Println(err.Error())
+        return
+    }
+
+    fmt.Printf("%s chose %s.", answers.Name, answers.FavoriteColor)
+}
+```
+
+## Table of Contents
+
+1. [Examples](#examples)
+1. [Prompts](#prompts)
+   1. [Input](#input)
+   1. [Multiline](#multiline)
+   1. [Password](#password)
+   1. [Confirm](#confirm)
+   1. [Select](#select)
+   1. [MultiSelect](#multiselect)
+   1. [Editor](#editor)
+1. [Validation](#validation)
+   1. [Built-in Validators](#built-in-validators)
+1. [Help Text](#help-text)
+   1. [Changing the input rune](#changing-the-input-run)
+1. [Custom Types](#custom-types)
+1. [Customizing Output](#customizing-output)
+1. [Versioning](#versioning)
+1. [Testing](#testing)
+
+## Examples
+
+Examples can be found in the `examples/` directory. Run them
+to see basic behavior:
+
+```bash
+go get gopkg.in/AlecAivazis/survey.v1
+
+cd $GOPATH/src/gopkg.in/AlecAivazis/survey.v1
+
+go run examples/simple.go
+go run examples/validation.go
+```
+
+## Prompts
+
+### Input
+
+<img src="https://thumbs.gfycat.com/LankyBlindAmericanpainthorse-size_restricted.gif" width="400px"/>
+
+```golang
+name := ""
+prompt := &survey.Input{
+    Message: "ping",
+}
+survey.AskOne(prompt, &name, nil)
+```
+
+### Multiline
+
+<img src="https://thumbs.gfycat.com/ImperfectShimmeringBeagle-size_restricted.gif" width="400px"/>
+
+```golang
+text := ""
+prompt := &survey.Multiline{
+    Message: "ping",
+}
+survey.AskOne(prompt, &text, nil)
+```
+
+### Password
+
+<img src="https://thumbs.gfycat.com/CompassionateSevereHypacrosaurus-size_restricted.gif" width="400px" />
+
+```golang
+password := ""
+prompt := &survey.Password{
+    Message: "Please type your password",
+}
+survey.AskOne(prompt, &password, nil)
+```
+
+### Confirm
+
+<img src="https://thumbs.gfycat.com/UnkemptCarefulGermanpinscher-size_restricted.gif" width="400px"/>
+
+```golang
+name := false
+prompt := &survey.Confirm{
+    Message: "Do you like pie?",
+}
+survey.AskOne(prompt, &name, nil)
+```
+
+### Select
+
+<img src="https://thumbs.gfycat.com/GrimFilthyAmazonparrot-size_restricted.gif" width="450px"/>
+
+```golang
+color := ""
+prompt := &survey.Select{
+    Message: "Choose a color:",
+    Options: []string{"red", "blue", "green"},
+}
+survey.AskOne(prompt, &color, nil)
+```
+
+The user can filter for options by typing while the prompt is active. The user can also press `esc` to toggle 
+the ability cycle through the options with the j and k keys to do down and up respectively.
+
+By default, the select prompt is limited to showing 7 options at a time
+and will paginate lists of options longer than that. To increase, you can either
+change the global `survey.PageSize`, or set the `PageSize` field on the prompt:
+
+```golang
+prompt := &survey.Select{..., PageSize: 10}
+```
+
+### MultiSelect
+
+<img src="https://thumbs.gfycat.com/SharpTameAntelope-size_restricted.gif" width="450px"/>
+
+```golang
+days := []string{}
+prompt := &survey.MultiSelect{
+    Message: "What days do you prefer:",
+    Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
+}
+survey.AskOne(prompt, &days, nil)
+```
+
+The user can filter for options by typing while the prompt is active. The user can also press `esc` to toggle 
+the ability cycle through the options with the j and k keys to do down and up respectively.
+
+By default, the MultiSelect prompt is limited to showing 7 options at a time
+and will paginate lists of options longer than that. To increase, you can either
+change the global `survey.PageSize`, or set the `PageSize` field on the prompt:
+
+```golang
+prompt := &survey.MultiSelect{..., PageSize: 10}
+```
+
+### Editor
+
+Launches the user's preferred editor (defined by the $EDITOR environment variable) on a
+temporary file. Once the user exits their editor, the contents of the temporary file are read in as
+the result. If neither of those are present, notepad (on Windows) or vim (Linux or Mac) is used.
+
+## Validation
+
+Validating individual responses for a particular question can be done by defining a
+`Validate` field on the `survey.Question` to be validated. This function takes an
+`interface{}` type and returns an error to show to the user, prompting them for another
+response:
+
+```golang
+q := &survey.Question{
+    Prompt: &survey.Input{Message: "Hello world validation"},
+    Validate: func (val interface{}) error {
+        // since we are validating an Input, the assertion will always succeed
+        if str, ok := val.(string) ; !ok || len(str) > 10 {
+            return errors.New("This response cannot be longer than 10 characters.")
+        }
+    }
+}
+```
+
+### Built-in Validators
+
+`survey` comes prepackaged with a few validators to fit common situations. Currently these
+validators include:
+
+| name         | valid types | description                                                 | notes                                                                                 |
+| ------------ | ----------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------- |
+| Required     | any         | Rejects zero values of the response type                    | Boolean values pass straight through since the zero value (false) is a valid response |
+| MinLength(n) | string      | Enforces that a response is at least the given length       |                                                                                       |
+| MaxLength(n) | string      | Enforces that a response is no longer than the given length |                                                                                       |
+
+## Help Text
+
+All of the prompts have a `Help` field which can be defined to provide more information to your users:
+
+<img src="https://thumbs.gfycat.com/CloudyRemorsefulFossa-size_restricted.gif" width="400px" style="margin-top: 8px"/>
+
+```golang
+&survey.Input{
+    Message: "What is your phone number:",
+    Help:    "Phone number should include the area code",
+}
+```
+
+### Changing the input rune
+
+In some situations, `?` is a perfectly valid response. To handle this, you can change the rune that survey
+looks for by setting the `HelpInputRune` variable in `survey/core`:
+
+```golang
+import (
+    "gopkg.in/AlecAivazis/survey.v1"
+    surveyCore "gopkg.in/AlecAivazis/survey.v1/core"
+)
+
+number := ""
+prompt := &survey.Input{
+    Message: "If you have this need, please give me a reasonable message.",
+    Help:    "I couldn't come up with one.",
+}
+
+surveyCore.HelpIcon = '^'
+
+survey.AskOne(prompt, &number, nil)
+```
+
+## Custom Types
+
+survey will assign prompt answers to your custom types if they implement this interface:
+
+```golang
+type settable interface {
+    WriteAnswer(field string, value interface{}) error
+}
+```
+
+Here is an example how to use them:
+
+```golang
+type MyValue struct {
+    value string
+}
+func (my *MyValue) WriteAnswer(name string, value interface{}) error {
+     my.value = value.(string)
+}
+
+myval := MyValue{}
+survey.AskOne(
+    &survey.Input{
+        Message: "Enter something:",
+    },
+    &myval,
+    nil,
+)
+```
+
+## Customizing Output
+
+Customizing the icons and various parts of survey can easily be done by setting the following variables
+in `survey/core`:
+
+| name               | default | description                                                   |
+| ------------------ | ------- | ------------------------------------------------------------- |
+| ErrorIcon          | X       | Before an error                                               |
+| HelpIcon           | i       | Before help text                                              |
+| QuestionIcon       | ?       | Before the message of a prompt                                |
+| SelectFocusIcon    | >       | Marks the current focus in `Select` and `MultiSelect` prompts |
+| UnmarkedOptionIcon | [ ]     | Marks an unselected option in a `MultiSelect` prompt          |
+| MarkedOptionIcon   | [x]     | Marks a chosen selection in a `MultiSelect` prompt            |
+
+## Versioning
+
+This project tries to maintain semantic GitHub releases as closely as possible and relies on [gopkg.in](http://labix.org/gopkg.in)
+to maintain those releases. Importing version 1 of survey would look like:
+
+```golang
+package main
+
+import "gopkg.in/AlecAivazis/survey.v1"
+```
+
+## Testing
+
+You can test your program's interactive prompts using [go-expect](https://github.com/Netflix/go-expect). The library
+can be used to expect a match on stdout and respond on stdin. Since `os.Stdout` in a `go test` process is not a TTY,
+if you are manipulating the cursor or using `survey`, you will need a way to interpret terminal / ANSI escape sequences
+for things like `CursorLocation`. `vt10x.NewVT10XConsole` will create a `go-expect` console that also multiplexes
+stdio to an in-memory [virtual terminal](https://github.com/hinshun/vt10x).
+
+For example, you can test a binary utilizing `survey` by connecting the Console's tty to a subprocess's stdio. 
+
+```go
+func TestCLI(t *testing.T) {
+ 	// Multiplex stdin/stdout to a virtual terminal to respond to ANSI escape
+ 	// sequences (i.e. cursor position report).
+ 	c, state, err := vt10x.NewVT10XConsole()
+	require.Nil(t, err)
+	defer c.Close()
+
+	donec := make(chan struct{})
+	go func() {
+		defer close(donec)
+    		c.ExpectString("What is your name?")
+    		c.SendLine("Johnny Appleseed")
+    		c.ExpectEOF()
+  	}()
+
+	cmd := exec.Command("your-cli")
+  	cmd.Stdin = c.Tty()
+  	cmd.Stdout = c.Tty()
+  	cmd.Stderr = c.Tty()
+
+  	err = cmd.Run()
+  	require.Nil(t, err)
+
+  	// Close the slave end of the pty, and read the remaining bytes from the master end.
+  	c.Tty().Close()
+  	<-donec
+
+  	// Dump the terminal's screen.
+  	t.Log(expect.StripTrailingEmptyLines(state.String()))
+}
+```
+
+If your application is decoupled from `os.Stdout` and `os.Stdin`, you can even test through the tty alone.
+`survey` itself is tested in this manner.
+
+```go
+func TestCLI(t *testing.T) {
+  	// Multiplex stdin/stdout to a virtual terminal to respond to ANSI escape
+  	// sequences (i.e. cursor position report).
+	c, state, err := vt10x.NewVT10XConsole()
+	require.Nil(t, err)
+  	defer c.Close()
+
+  	donec := make(chan struct{})
+	go func() {
+    		defer close(donec)
+    		c.ExpectString("What is your name?")
+    		c.SendLine("Johnny Appleseed")
+    		c.ExpectEOF()
+	}()
+
+  	prompt := &Input{
+    		Message: "What is your name?",
+  	}
+  	prompt.WithStdio(Stdio(c))
+
+  	answer, err := prompt.Prompt()
+  	require.Nil(t, err)
+  	require.Equal(t, "Johnny Appleseed", answer)
+
+  	// Close the slave end of the pty, and read the remaining bytes from the master end.
+  	c.Tty().Close()
+  	<-donec
+
+  	// Dump the terminal's screen.
+  	t.Log(expect.StripTrailingEmptyLines(state.String()))
+}
+```

vendor/github.com/AlecAivazis/survey/_tasks.yml

@@ -0,0 +1,23 @@
+autoplay-tests:
+  summary: Replaying interactive tests
+  command: |-
+    cd tests
+    set -e
+    for test in autoplay/*.go; do
+      echo "==> Running $test"
+      go run $test
+    done
+
+install-deps:
+  summary: Install all of package dependencies
+  command: |-
+    go get -t {{.files}}
+    # for autoplay tests
+    go get github.com/kr/pty
+
+tests:
+  summary: Run the test suite
+  command: go test {{.files}}
+
+variables:
+  files: '$(go list -v ./... | grep -iEv "tests|examples")'

vendor/github.com/AlecAivazis/survey/confirm.go

@@ -0,0 +1,138 @@
+package survey
+
+import (
+	"fmt"
+	"regexp"
+
+	"gopkg.in/AlecAivazis/survey.v1/core"
+)
+
+// Confirm is a regular text input that accept yes/no answers. Response type is a bool.
+type Confirm struct {
+	core.Renderer
+	Message string
+	Default bool
+	Help    string
+}
+
+// data available to the templates when processing
+type ConfirmTemplateData struct {
+	Confirm
+	Answer   string
+	ShowHelp bool
+}
+
+// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+var ConfirmQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }} {{color "reset"}}
+{{- if .Answer}}
+  {{- color "cyan"}}{{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else }}
+  {{- if and .Help (not .ShowHelp)}}{{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}} {{end}}
+  {{- color "white"}}{{if .Default}}(Y/n) {{else}}(y/N) {{end}}{{color "reset"}}
+{{- end}}`
+
+// the regex for answers
+var (
+	yesRx = regexp.MustCompile("^(?i:y(?:es)?)$")
+	noRx  = regexp.MustCompile("^(?i:n(?:o)?)$")
+)
+
+func yesNo(t bool) string {
+	if t {
+		return "Yes"
+	}
+	return "No"
+}
+
+func (c *Confirm) getBool(showHelp bool) (bool, error) {
+	cursor := c.NewCursor()
+	rr := c.NewRuneReader()
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	// start waiting for input
+	for {
+		line, err := rr.ReadLine(0)
+		if err != nil {
+			return false, err
+		}
+		// move back up a line to compensate for the \n echoed from terminal
+		cursor.PreviousLine(1)
+		val := string(line)
+
+		// get the answer that matches the
+		var answer bool
+		switch {
+		case yesRx.Match([]byte(val)):
+			answer = true
+		case noRx.Match([]byte(val)):
+			answer = false
+		case val == "":
+			answer = c.Default
+		case val == string(core.HelpInputRune) && c.Help != "":
+			err := c.Render(
+				ConfirmQuestionTemplate,
+				ConfirmTemplateData{Confirm: *c, ShowHelp: true},
+			)
+			if err != nil {
+				// use the default value and bubble up
+				return c.Default, err
+			}
+			showHelp = true
+			continue
+		default:
+			// we didnt get a valid answer, so print error and prompt again
+			if err := c.Error(fmt.Errorf("%q is not a valid answer, please try again.", val)); err != nil {
+				return c.Default, err
+			}
+			err := c.Render(
+				ConfirmQuestionTemplate,
+				ConfirmTemplateData{Confirm: *c, ShowHelp: showHelp},
+			)
+			if err != nil {
+				// use the default value and bubble up
+				return c.Default, err
+			}
+			continue
+		}
+		return answer, nil
+	}
+	// should not get here
+	return c.Default, nil
+}
+
+/*
+Prompt prompts the user with a simple text field and expects a reply followed
+by a carriage return.
+
+	likesPie := false
+	prompt := &survey.Confirm{ Message: "What is your name?" }
+	survey.AskOne(prompt, &likesPie, nil)
+*/
+func (c *Confirm) Prompt() (interface{}, error) {
+	// render the question template
+	err := c.Render(
+		ConfirmQuestionTemplate,
+		ConfirmTemplateData{Confirm: *c},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	// get input and return
+	return c.getBool(false)
+}
+
+// Cleanup overwrite the line with the finalized formatted version
+func (c *Confirm) Cleanup(val interface{}) error {
+	// if the value was previously true
+	ans := yesNo(val.(bool))
+	// render the template
+	return c.Render(
+		ConfirmQuestionTemplate,
+		ConfirmTemplateData{Confirm: *c, Answer: ans},
+	)
+}

vendor/github.com/AlecAivazis/survey/editor.go

@@ -0,0 +1,194 @@
+package survey
+
+import (
+	"bytes"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"runtime"
+
+	shellquote "github.com/kballard/go-shellquote"
+	"gopkg.in/AlecAivazis/survey.v1/core"
+	"gopkg.in/AlecAivazis/survey.v1/terminal"
+)
+
+/*
+Editor launches an instance of the users preferred editor on a temporary file.
+The editor to use is determined by reading the $VISUAL or $EDITOR environment
+variables. If neither of those are present, notepad (on Windows) or vim
+(others) is used.
+The launch of the editor is triggered by the enter key. Since the response may
+be long, it will not be echoed as Input does, instead, it print <Received>.
+Response type is a string.
+
+	message := ""
+	prompt := &survey.Editor{ Message: "What is your commit message?" }
+	survey.AskOne(prompt, &message, nil)
+*/
+type Editor struct {
+	core.Renderer
+	Message       string
+	Default       string
+	Help          string
+	Editor        string
+	HideDefault   bool
+	AppendDefault bool
+}
+
+// data available to the templates when processing
+type EditorTemplateData struct {
+	Editor
+	Answer     string
+	ShowAnswer bool
+	ShowHelp   bool
+}
+
+// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+var EditorQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }} {{color "reset"}}
+{{- if .ShowAnswer}}
+  {{- color "cyan"}}{{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else }}
+  {{- if and .Help (not .ShowHelp)}}{{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}} {{end}}
+  {{- if and .Default (not .HideDefault)}}{{color "white"}}({{.Default}}) {{color "reset"}}{{end}}
+  {{- color "cyan"}}[Enter to launch editor] {{color "reset"}}
+{{- end}}`
+
+var (
+	bom    = []byte{0xef, 0xbb, 0xbf}
+	editor = "vim"
+)
+
+func init() {
+	if runtime.GOOS == "windows" {
+		editor = "notepad"
+	}
+	if v := os.Getenv("VISUAL"); v != "" {
+		editor = v
+	} else if e := os.Getenv("EDITOR"); e != "" {
+		editor = e
+	}
+}
+
+func (e *Editor) Prompt() (interface{}, error) {
+	// render the template
+	err := e.Render(
+		EditorQuestionTemplate,
+		EditorTemplateData{Editor: *e},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	// start reading runes from the standard in
+	rr := e.NewRuneReader()
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	cursor := e.NewCursor()
+	cursor.Hide()
+	defer cursor.Show()
+
+	for {
+		r, _, err := rr.ReadRune()
+		if err != nil {
+			return "", err
+		}
+		if r == '\r' || r == '\n' {
+			break
+		}
+		if r == terminal.KeyInterrupt {
+			return "", terminal.InterruptErr
+		}
+		if r == terminal.KeyEndTransmission {
+			break
+		}
+		if r == core.HelpInputRune && e.Help != "" {
+			err = e.Render(
+				EditorQuestionTemplate,
+				EditorTemplateData{Editor: *e, ShowHelp: true},
+			)
+			if err != nil {
+				return "", err
+			}
+		}
+		continue
+	}
+
+	// prepare the temp file
+	f, err := ioutil.TempFile("", "survey")
+	if err != nil {
+		return "", err
+	}
+	defer os.Remove(f.Name())
+
+	// write utf8 BOM header
+	// The reason why we do this is because notepad.exe on Windows determines the
+	// encoding of an "empty" text file by the locale, for example, GBK in China,
+	// while golang string only handles utf8 well. However, a text file with utf8
+	// BOM header is not considered "empty" on Windows, and the encoding will then
+	// be determined utf8 by notepad.exe, instead of GBK or other encodings.
+	if _, err := f.Write(bom); err != nil {
+		return "", err
+	}
+
+	// write default value
+	if e.Default != "" && e.AppendDefault {
+		if _, err := f.WriteString(e.Default); err != nil {
+			return "", err
+		}
+	}
+
+	// close the fd to prevent the editor unable to save file
+	if err := f.Close(); err != nil {
+		return "", err
+	}
+
+	// check is input editor exist
+	if e.Editor != "" {
+		editor = e.Editor
+	}
+
+	stdio := e.Stdio()
+
+	args, err := shellquote.Split(editor)
+	if err != nil {
+		return "", err
+	}
+	args = append(args, f.Name())
+
+	// open the editor
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdin = stdio.In
+	cmd.Stdout = stdio.Out
+	cmd.Stderr = stdio.Err
+	cursor.Show()
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+
+	// raw is a BOM-unstripped UTF8 byte slice
+	raw, err := ioutil.ReadFile(f.Name())
+	if err != nil {
+		return "", err
+	}
+
+	// strip BOM header
+	text := string(bytes.TrimPrefix(raw, bom))
+
+	// check length, return default value on empty
+	if len(text) == 0 && !e.AppendDefault {
+		return e.Default, nil
+	}
+
+	return text, nil
+}
+
+func (e *Editor) Cleanup(val interface{}) error {
+	return e.Render(
+		EditorQuestionTemplate,
+		EditorTemplateData{Editor: *e, Answer: "<Received>", ShowAnswer: true},
+	)
+}

vendor/github.com/AlecAivazis/survey/input.go

@@ -0,0 +1,97 @@
+package survey
+
+import (
+	"gopkg.in/AlecAivazis/survey.v1/core"
+)
+
+/*
+Input is a regular text input that prints each character the user types on the screen
+and accepts the input with the enter key. Response type is a string.
+
+	name := ""
+	prompt := &survey.Input{ Message: "What is your name?" }
+	survey.AskOne(prompt, &name, nil)
+*/
+type Input struct {
+	core.Renderer
+	Message string
+	Default string
+	Help    string
+}
+
+// data available to the templates when processing
+type InputTemplateData struct {
+	Input
+	Answer     string
+	ShowAnswer bool
+	ShowHelp   bool
+}
+
+// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+var InputQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }} {{color "reset"}}
+{{- if .ShowAnswer}}
+  {{- color "cyan"}}{{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else }}
+  {{- if and .Help (not .ShowHelp)}}{{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}} {{end}}
+  {{- if .Default}}{{color "white"}}({{.Default}}) {{color "reset"}}{{end}}
+{{- end}}`
+
+func (i *Input) Prompt() (interface{}, error) {
+	// render the template
+	err := i.Render(
+		InputQuestionTemplate,
+		InputTemplateData{Input: *i},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	// start reading runes from the standard in
+	rr := i.NewRuneReader()
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	cursor := i.NewCursor()
+
+	line := []rune{}
+	// get the next line
+	for {
+		line, err = rr.ReadLine(0)
+		if err != nil {
+			return string(line), err
+		}
+		// terminal will echo the \n so we need to jump back up one row
+		cursor.PreviousLine(1)
+
+		if string(line) == string(core.HelpInputRune) && i.Help != "" {
+			err = i.Render(
+				InputQuestionTemplate,
+				InputTemplateData{Input: *i, ShowHelp: true},
+			)
+			if err != nil {
+				return "", err
+			}
+			continue
+		}
+		break
+	}
+
+	// if the line is empty
+	if line == nil || len(line) == 0 {
+		// use the default value
+		return i.Default, err
+	}
+
+	// we're done
+	return string(line), err
+}
+
+func (i *Input) Cleanup(val interface{}) error {
+	return i.Render(
+		InputQuestionTemplate,
+		InputTemplateData{Input: *i, Answer: val.(string), ShowAnswer: true},
+	)
+}

vendor/github.com/AlecAivazis/survey/multiline.go

@@ -0,0 +1,103 @@
+package survey
+
+import (
+	"fmt"
+	"strings"
+
+	"gopkg.in/AlecAivazis/survey.v1/core"
+	"gopkg.in/AlecAivazis/survey.v1/terminal"
+)
+
+type Multiline struct {
+	core.Renderer
+	Message string
+	Default string
+	Help    string
+}
+
+// data available to the templates when processing
+type MultilineTemplateData struct {
+	Multiline
+	Answer     string
+	ShowAnswer bool
+	ShowHelp   bool
+}
+
+// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+var MultilineQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }} {{color "reset"}}
+{{- if .ShowAnswer}}
+  {{- "\n"}}{{color "cyan"}}{{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else }}
+  {{- if .Default}}{{color "white"}}({{.Default}}) {{color "reset"}}{{end}}
+  {{- color "cyan"}}[Enter 2 empty lines to finish]{{color "reset"}}
+{{- end}}`
+
+func (i *Multiline) Prompt() (interface{}, error) {
+	// render the template
+	err := i.Render(
+		MultilineQuestionTemplate,
+		MultilineTemplateData{Multiline: *i},
+	)
+	if err != nil {
+		return "", err
+	}
+	fmt.Println()
+
+	// start reading runes from the standard in
+	rr := i.NewRuneReader()
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	cursor := i.NewCursor()
+
+	multiline := make([]string, 0)
+
+	emptyOnce := false
+	// get the next line
+	for {
+		line := []rune{}
+		line, err = rr.ReadLine(0)
+		if err != nil {
+			return string(line), err
+		}
+
+		if string(line) == "" {
+			if emptyOnce {
+				numLines := len(multiline) + 2
+				cursor.PreviousLine(numLines)
+				for j := 0; j < numLines; j++ {
+					terminal.EraseLine(i.Stdio().Out, terminal.ERASE_LINE_ALL)
+					cursor.NextLine(1)
+				}
+				cursor.PreviousLine(numLines)
+				break
+			}
+			emptyOnce = true
+		} else {
+			emptyOnce = false
+		}
+		multiline = append(multiline, string(line))
+	}
+
+	val := strings.Join(multiline, "\n")
+	val = strings.TrimSpace(val)
+
+	// if the line is empty
+	if len(val) == 0 {
+		// use the default value
+		return i.Default, err
+	}
+
+	// we're done
+	return val, err
+}
+
+func (i *Multiline) Cleanup(val interface{}) error {
+	return i.Render(
+		MultilineQuestionTemplate,
+		MultilineTemplateData{Multiline: *i, Answer: val.(string), ShowAnswer: true},
+	)
+}

vendor/github.com/AlecAivazis/survey/multiselect.go

@@ -0,0 +1,251 @@
+package survey
+
+import (
+	"errors"
+	"strings"
+
+	"gopkg.in/AlecAivazis/survey.v1/core"
+	"gopkg.in/AlecAivazis/survey.v1/terminal"
+)
+
+/*
+MultiSelect is a prompt that presents a list of various options to the user
+for them to select using the arrow keys and enter. Response type is a slice of strings.
+
+	days := []string{}
+	prompt := &survey.MultiSelect{
+		Message: "What days do you prefer:",
+		Options: []string{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"},
+	}
+	survey.AskOne(prompt, &days, nil)
+*/
+type MultiSelect struct {
+	core.Renderer
+	Message       string
+	Options       []string
+	Default       []string
+	Help          string
+	PageSize      int
+	VimMode       bool
+	FilterMessage string
+	filter        string
+	selectedIndex int
+	checked       map[string]bool
+	showingHelp   bool
+}
+
+// data available to the templates when processing
+type MultiSelectTemplateData struct {
+	MultiSelect
+	Answer        string
+	ShowAnswer    bool
+	Checked       map[string]bool
+	SelectedIndex int
+	ShowHelp      bool
+	PageEntries   []string
+}
+
+var MultiSelectQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }}{{ .FilterMessage }}{{color "reset"}}
+{{- if .ShowAnswer}}{{color "cyan"}} {{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else }}
+	{{- "  "}}{{- color "cyan"}}[Use arrows to move, type to filter{{- if and .Help (not .ShowHelp)}}, {{ HelpInputRune }} for more help{{end}}]{{color "reset"}}
+  {{- "\n"}}
+  {{- range $ix, $option := .PageEntries}}
+    {{- if eq $ix $.SelectedIndex}}{{color "cyan"}}{{ SelectFocusIcon }}{{color "reset"}}{{else}} {{end}}
+    {{- if index $.Checked $option}}{{color "green"}} {{ MarkedOptionIcon }} {{else}}{{color "default+hb"}} {{ UnmarkedOptionIcon }} {{end}}
+    {{- color "reset"}}
+    {{- " "}}{{$option}}{{"\n"}}
+  {{- end}}
+{{- end}}`
+
+// OnChange is called on every keypress.
+func (m *MultiSelect) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool) {
+	options := m.filterOptions()
+	oldFilter := m.filter
+
+	if key == terminal.KeyArrowUp || (m.VimMode && key == 'k') {
+		// if we are at the top of the list
+		if m.selectedIndex == 0 {
+			// go to the bottom
+			m.selectedIndex = len(options) - 1
+		} else {
+			// decrement the selected index
+			m.selectedIndex--
+		}
+	} else if key == terminal.KeyArrowDown || (m.VimMode && key == 'j') {
+		// if we are at the bottom of the list
+		if m.selectedIndex == len(options)-1 {
+			// start at the top
+			m.selectedIndex = 0
+		} else {
+			// increment the selected index
+			m.selectedIndex++
+		}
+		// if the user pressed down and there is room to move
+	} else if key == terminal.KeySpace {
+		if m.selectedIndex < len(options) {
+			if old, ok := m.checked[options[m.selectedIndex]]; !ok {
+				// otherwise just invert the current value
+				m.checked[options[m.selectedIndex]] = true
+			} else {
+				// otherwise just invert the current value
+				m.checked[options[m.selectedIndex]] = !old
+			}
+			m.filter = ""
+		}
+		// only show the help message if we have one to show
+	} else if key == core.HelpInputRune && m.Help != "" {
+		m.showingHelp = true
+	} else if key == terminal.KeyEscape {
+		m.VimMode = !m.VimMode
+	} else if key == terminal.KeyDeleteWord || key == terminal.KeyDeleteLine {
+		m.filter = ""
+	} else if key == terminal.KeyDelete || key == terminal.KeyBackspace {
+		if m.filter != "" {
+			m.filter = m.filter[0 : len(m.filter)-1]
+		}
+	} else if key >= terminal.KeySpace {
+		m.filter += string(key)
+		m.VimMode = false
+	}
+
+	m.FilterMessage = ""
+	if m.filter != "" {
+		m.FilterMessage = " " + m.filter
+	}
+	if oldFilter != m.filter {
+		// filter changed
+		options = m.filterOptions()
+		if len(options) > 0 && len(options) <= m.selectedIndex {
+			m.selectedIndex = len(options) - 1
+		}
+	}
+	// paginate the options
+
+	// TODO if we have started filtering and were looking at the end of a list
+	// and we have modified the filter then we should move the page back!
+	opts, idx := paginate(m.PageSize, options, m.selectedIndex)
+
+	// render the options
+	m.Render(
+		MultiSelectQuestionTemplate,
+		MultiSelectTemplateData{
+			MultiSelect:   *m,
+			SelectedIndex: idx,
+			Checked:       m.checked,
+			ShowHelp:      m.showingHelp,
+			PageEntries:   opts,
+		},
+	)
+
+	// if we are not pressing ent
+	return line, 0, true
+}
+
+func (m *MultiSelect) filterOptions() []string {
+	filter := strings.ToLower(m.filter)
+	if filter == "" {
+		return m.Options
+	}
+	answer := []string{}
+	for _, o := range m.Options {
+		if strings.Contains(strings.ToLower(o), filter) {
+			answer = append(answer, o)
+		}
+	}
+	return answer
+}
+
+func (m *MultiSelect) Prompt() (interface{}, error) {
+	// compute the default state
+	m.checked = make(map[string]bool)
+	// if there is a default
+	if len(m.Default) > 0 {
+		for _, dflt := range m.Default {
+			for _, opt := range m.Options {
+				// if the option correponds to the default
+				if opt == dflt {
+					// we found our initial value
+					m.checked[opt] = true
+					// stop looking
+					break
+				}
+			}
+		}
+	}
+
+	// if there are no options to render
+	if len(m.Options) == 0 {
+		// we failed
+		return "", errors.New("please provide options to select from")
+	}
+
+	// paginate the options
+	opts, idx := paginate(m.PageSize, m.Options, m.selectedIndex)
+
+	cursor := m.NewCursor()
+	cursor.Hide()       // hide the cursor
+	defer cursor.Show() // show the cursor when we're done
+
+	// ask the question
+	err := m.Render(
+		MultiSelectQuestionTemplate,
+		MultiSelectTemplateData{
+			MultiSelect:   *m,
+			SelectedIndex: idx,
+			Checked:       m.checked,
+			PageEntries:   opts,
+		},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	rr := m.NewRuneReader()
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	// start waiting for input
+	for {
+		r, _, _ := rr.ReadRune()
+		if r == '\r' || r == '\n' {
+			break
+		}
+		if r == terminal.KeyInterrupt {
+			return "", terminal.InterruptErr
+		}
+		if r == terminal.KeyEndTransmission {
+			break
+		}
+		m.OnChange(nil, 0, r)
+	}
+	m.filter = ""
+	m.FilterMessage = ""
+
+	answers := []string{}
+	for _, option := range m.Options {
+		if val, ok := m.checked[option]; ok && val {
+			answers = append(answers, option)
+		}
+	}
+
+	return answers, nil
+}
+
+// Cleanup removes the options section, and renders the ask like a normal question.
+func (m *MultiSelect) Cleanup(val interface{}) error {
+	// execute the output summary template with the answer
+	return m.Render(
+		MultiSelectQuestionTemplate,
+		MultiSelectTemplateData{
+			MultiSelect:   *m,
+			SelectedIndex: m.selectedIndex,
+			Checked:       m.checked,
+			Answer:        strings.Join(val.([]string), ", "),
+			ShowAnswer:    true,
+		},
+	)
+}

vendor/github.com/AlecAivazis/survey/password.go

@@ -0,0 +1,86 @@
+package survey
+
+import (
+	"fmt"
+
+	"gopkg.in/AlecAivazis/survey.v1/core"
+	"gopkg.in/AlecAivazis/survey.v1/terminal"
+)
+
+/*
+Password is like a normal Input but the text shows up as *'s and there is no default. Response
+type is a string.
+
+	password := ""
+	prompt := &survey.Password{ Message: "Please type your password" }
+	survey.AskOne(prompt, &password, nil)
+*/
+type Password struct {
+	core.Renderer
+	Message string
+	Help    string
+}
+
+type PasswordTemplateData struct {
+	Password
+	ShowHelp bool
+}
+
+// Templates with Color formatting. See Documentation: https://github.com/mgutz/ansi#style-format
+var PasswordQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }} {{color "reset"}}
+{{- if and .Help (not .ShowHelp)}}{{color "cyan"}}[{{ HelpInputRune }} for help]{{color "reset"}} {{end}}`
+
+func (p *Password) Prompt() (line interface{}, err error) {
+	// render the question template
+	out, err := core.RunTemplate(
+		PasswordQuestionTemplate,
+		PasswordTemplateData{Password: *p},
+	)
+	fmt.Fprint(terminal.NewAnsiStdout(p.Stdio().Out), out)
+	if err != nil {
+		return "", err
+	}
+
+	rr := p.NewRuneReader()
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	// no help msg?  Just return any response
+	if p.Help == "" {
+		line, err := rr.ReadLine('*')
+		return string(line), err
+	}
+
+	cursor := p.NewCursor()
+
+	// process answers looking for help prompt answer
+	for {
+		line, err := rr.ReadLine('*')
+		if err != nil {
+			return string(line), err
+		}
+
+		if string(line) == string(core.HelpInputRune) {
+			// terminal will echo the \n so we need to jump back up one row
+			cursor.PreviousLine(1)
+
+			err = p.Render(
+				PasswordQuestionTemplate,
+				PasswordTemplateData{Password: *p, ShowHelp: true},
+			)
+			if err != nil {
+				return "", err
+			}
+			continue
+		}
+		return string(line), err
+	}
+}
+
+// Cleanup hides the string with a fixed number of characters.
+func (prompt *Password) Cleanup(val interface{}) error {
+	return nil
+}

vendor/github.com/AlecAivazis/survey/select.go

@@ -0,0 +1,271 @@
+package survey
+
+import (
+	"errors"
+	"strings"
+
+	"gopkg.in/AlecAivazis/survey.v1/core"
+	"gopkg.in/AlecAivazis/survey.v1/terminal"
+)
+
+/*
+Select is a prompt that presents a list of various options to the user
+for them to select using the arrow keys and enter. Response type is a string.
+
+	color := ""
+	prompt := &survey.Select{
+		Message: "Choose a color:",
+		Options: []string{"red", "blue", "green"},
+	}
+	survey.AskOne(prompt, &color, nil)
+*/
+type Select struct {
+	core.Renderer
+	Message       string
+	Options       []string
+	Default       string
+	Help          string
+	PageSize      int
+	VimMode       bool
+	FilterMessage string
+	filter        string
+	selectedIndex int
+	useDefault    bool
+	showingHelp   bool
+}
+
+// the data available to the templates when processing
+type SelectTemplateData struct {
+	Select
+	PageEntries   []string
+	SelectedIndex int
+	Answer        string
+	ShowAnswer    bool
+	ShowHelp      bool
+}
+
+var SelectQuestionTemplate = `
+{{- if .ShowHelp }}{{- color "cyan"}}{{ HelpIcon }} {{ .Help }}{{color "reset"}}{{"\n"}}{{end}}
+{{- color "green+hb"}}{{ QuestionIcon }} {{color "reset"}}
+{{- color "default+hb"}}{{ .Message }}{{ .FilterMessage }}{{color "reset"}}
+{{- if .ShowAnswer}}{{color "cyan"}} {{.Answer}}{{color "reset"}}{{"\n"}}
+{{- else}}
+  {{- "  "}}{{- color "cyan"}}[Use arrows to move, type to filter{{- if and .Help (not .ShowHelp)}}, {{ HelpInputRune }} for more help{{end}}]{{color "reset"}}
+  {{- "\n"}}
+  {{- range $ix, $choice := .PageEntries}}
+    {{- if eq $ix $.SelectedIndex}}{{color "cyan+b"}}{{ SelectFocusIcon }} {{else}}{{color "default+hb"}}  {{end}}
+    {{- $choice}}
+    {{- color "reset"}}{{"\n"}}
+  {{- end}}
+{{- end}}`
+
+// OnChange is called on every keypress.
+func (s *Select) OnChange(line []rune, pos int, key rune) (newLine []rune, newPos int, ok bool) {
+	options := s.filterOptions()
+	oldFilter := s.filter
+
+	// if the user pressed the enter key
+	if key == terminal.KeyEnter {
+		if s.selectedIndex < len(options) {
+			return []rune(options[s.selectedIndex]), 0, true
+		}
+		// if the user pressed the up arrow or 'k' to emulate vim
+	} else if key == terminal.KeyArrowUp || (s.VimMode && key == 'k') {
+		s.useDefault = false
+
+		// if we are at the top of the list
+		if s.selectedIndex == 0 {
+			// start from the button
+			s.selectedIndex = len(options) - 1
+		} else {
+			// otherwise we are not at the top of the list so decrement the selected index
+			s.selectedIndex--
+		}
+		// if the user pressed down or 'j' to emulate vim
+	} else if key == terminal.KeyArrowDown || (s.VimMode && key == 'j') {
+		s.useDefault = false
+		// if we are at the bottom of the list
+		if s.selectedIndex == len(options)-1 {
+			// start from the top
+			s.selectedIndex = 0
+		} else {
+			// increment the selected index
+			s.selectedIndex++
+		}
+		// only show the help message if we have one
+	} else if key == core.HelpInputRune && s.Help != "" {
+		s.showingHelp = true
+		// if the user wants to toggle vim mode on/off
+	} else if key == terminal.KeyEscape {
+		s.VimMode = !s.VimMode
+		// if the user hits any of the keys that clear the filter
+	} else if key == terminal.KeyDeleteWord || key == terminal.KeyDeleteLine {
+		s.filter = ""
+		// if the user is deleting a character in the filter
+	} else if key == terminal.KeyDelete || key == terminal.KeyBackspace {
+		// if there is content in the filter to delete
+		if s.filter != "" {
+			// subtract a line from the current filter
+			s.filter = s.filter[0 : len(s.filter)-1]
+			// we removed the last value in the filter
+		}
+	} else if key >= terminal.KeySpace {
+		s.filter += string(key)
+		// make sure vim mode is disabled
+		s.VimMode = false
+		// make sure that we use the current value in the filtered list
+		s.useDefault = false
+	}
+
+	s.FilterMessage = ""
+	if s.filter != "" {
+		s.FilterMessage = " " + s.filter
+	}
+	if oldFilter != s.filter {
+		// filter changed
+		options = s.filterOptions()
+		if len(options) > 0 && len(options) <= s.selectedIndex {
+			s.selectedIndex = len(options) - 1
+		}
+	}
+
+	// figure out the options and index to render
+
+	// TODO if we have started filtering and were looking at the end of a list
+	// and we have modified the filter then we should move the page back!
+	opts, idx := paginate(s.PageSize, options, s.selectedIndex)
+
+	// render the options
+	s.Render(
+		SelectQuestionTemplate,
+		SelectTemplateData{
+			Select:        *s,
+			SelectedIndex: idx,
+			ShowHelp:      s.showingHelp,
+			PageEntries:   opts,
+		},
+	)
+
+	// if we are not pressing ent
+	if len(options) <= s.selectedIndex {
+		return []rune{}, 0, false
+	}
+	return []rune(options[s.selectedIndex]), 0, true
+}
+
+func (s *Select) filterOptions() []string {
+	filter := strings.ToLower(s.filter)
+	if filter == "" {
+		return s.Options
+	}
+	answer := []string{}
+	for _, o := range s.Options {
+		if strings.Contains(strings.ToLower(o), filter) {
+			answer = append(answer, o)
+		}
+	}
+	return answer
+}
+
+func (s *Select) Prompt() (interface{}, error) {
+	// if there are no options to render
+	if len(s.Options) == 0 {
+		// we failed
+		return "", errors.New("please provide options to select from")
+	}
+
+	// start off with the first option selected
+	sel := 0
+	// if there is a default
+	if s.Default != "" {
+		// find the choice
+		for i, opt := range s.Options {
+			// if the option correponds to the default
+			if opt == s.Default {
+				// we found our initial value
+				sel = i
+				// stop looking
+				break
+			}
+		}
+	}
+	// save the selected index
+	s.selectedIndex = sel
+
+	// figure out the options and index to render
+	opts, idx := paginate(s.PageSize, s.Options, sel)
+
+	// ask the question
+	err := s.Render(
+		SelectQuestionTemplate,
+		SelectTemplateData{
+			Select:        *s,
+			PageEntries:   opts,
+			SelectedIndex: idx,
+		},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	// by default, use the default value
+	s.useDefault = true
+
+	rr := s.NewRuneReader()
+	rr.SetTermMode()
+	defer rr.RestoreTermMode()
+
+	cursor := s.NewCursor()
+	cursor.Hide()       // hide the cursor
+	defer cursor.Show() // show the cursor when we're done
+
+	// start waiting for input
+	for {
+		r, _, err := rr.ReadRune()
+		if err != nil {
+			return "", err
+		}
+		if r == '\r' || r == '\n' {
+			break
+		}
+		if r == terminal.KeyInterrupt {
+			return "", terminal.InterruptErr
+		}
+		if r == terminal.KeyEndTransmission {
+			break
+		}
+		s.OnChange(nil, 0, r)
+	}
+	options := s.filterOptions()
+	s.filter = ""
+	s.FilterMessage = ""
+
+	var val string
+	// if we are supposed to use the default value
+	if s.useDefault || s.selectedIndex >= len(options) {
+		// if there is a default value
+		if s.Default != "" {
+			// use the default value
+			val = s.Default
+		} else if len(options) > 0 {
+			// there is no default value so use the first
+			val = options[0]
+		}
+		// otherwise the selected index points to the value
+	} else if s.selectedIndex < len(options) {
+		// the
+		val = options[s.selectedIndex]
+	}
+	return val, err
+}
+
+func (s *Select) Cleanup(val interface{}) error {
+	return s.Render(
+		SelectQuestionTemplate,
+		SelectTemplateData{
+			Select:     *s,
+			Answer:     val.(string),
+			ShowAnswer: true,
+		},
+	)
+}

vendor/github.com/AlecAivazis/survey/survey.go

@@ -0,0 +1,246 @@
+package survey
+
+import (
+	"errors"
+	"io"
+	"os"
+
+	"gopkg.in/AlecAivazis/survey.v1/core"
+	"gopkg.in/AlecAivazis/survey.v1/terminal"
+)
+
+// PageSize is the default maximum number of items to show in select/multiselect prompts
+var PageSize = 7
+
+// DefaultAskOptions is the default options on ask, using the OS stdio.
+var DefaultAskOptions = AskOptions{
+	Stdio: terminal.Stdio{
+		In:  os.Stdin,
+		Out: os.Stdout,
+		Err: os.Stderr,
+	},
+}
+
+// Validator is a function passed to a Question after a user has provided a response.
+// If the function returns an error, then the user will be prompted again for another
+// response.
+type Validator func(ans interface{}) error
+
+// Transformer is a function passed to a Question after a user has provided a response.
+// The function can be used to implement a custom logic that will result to return
+// a different representation of the given answer.
+//
+// Look `TransformString`, `ToLower` `Title` and `ComposeTransformers` for more.
+type Transformer func(ans interface{}) (newAns interface{})
+
+// Question is the core data structure for a survey questionnaire.
+type Question struct {
+	Name      string
+	Prompt    Prompt
+	Validate  Validator
+	Transform Transformer
+}
+
+// Prompt is the primary interface for the objects that can take user input
+// and return a response.
+type Prompt interface {
+	Prompt() (interface{}, error)
+	Cleanup(interface{}) error
+	Error(error) error
+}
+
+// AskOpt allows setting optional ask options.
+type AskOpt func(options *AskOptions) error
+
+// AskOptions provides additional options on ask.
+type AskOptions struct {
+	Stdio terminal.Stdio
+}
+
+// WithStdio specifies the standard input, output and error files survey
+// interacts with. By default, these are os.Stdin, os.Stdout, and os.Stderr.
+func WithStdio(in terminal.FileReader, out terminal.FileWriter, err io.Writer) AskOpt {
+	return func(options *AskOptions) error {
+		options.Stdio.In = in
+		options.Stdio.Out = out
+		options.Stdio.Err = err
+		return nil
+	}
+}
+
+type wantsStdio interface {
+	WithStdio(terminal.Stdio)
+}
+
+/*
+AskOne performs the prompt for a single prompt and asks for validation if required.
+Response types should be something that can be casted from the response type designated
+in the documentation. For example:
+
+	name := ""
+	prompt := &survey.Input{
+		Message: "name",
+	}
+
+	survey.AskOne(prompt, &name, nil)
+
+*/
+func AskOne(p Prompt, response interface{}, v Validator, opts ...AskOpt) error {
+	err := Ask([]*Question{{Prompt: p, Validate: v}}, response, opts...)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+/*
+Ask performs the prompt loop, asking for validation when appropriate. The response
+type can be one of two options. If a struct is passed, the answer will be written to
+the field whose name matches the Name field on the corresponding question. Field types
+should be something that can be casted from the response type designated in the
+documentation. Note, a survey tag can also be used to identify a Otherwise, a
+map[string]interface{} can be passed, responses will be written to the key with the
+matching name. For example:
+
+	qs := []*survey.Question{
+		{
+			Name:     "name",
+			Prompt:   &survey.Input{Message: "What is your name?"},
+			Validate: survey.Required,
+			Transform: survey.Title,
+		},
+	}
+
+	answers := struct{ Name string }{}
+
+
+	err := survey.Ask(qs, &answers)
+*/
+func Ask(qs []*Question, response interface{}, opts ...AskOpt) error {
+
+	options := DefaultAskOptions
+	for _, opt := range opts {
+		if err := opt(&options); err != nil {
+			return err
+		}
+	}
+
+	// if we weren't passed a place to record the answers
+	if response == nil {
+		// we can't go any further
+		return errors.New("cannot call Ask() with a nil reference to record the answers")
+	}
+
+	// go over every question
+	for _, q := range qs {
+		// If Prompt implements controllable stdio, pass in specified stdio.
+		if p, ok := q.Prompt.(wantsStdio); ok {
+			p.WithStdio(options.Stdio)
+		}
+
+		// grab the user input and save it
+		ans, err := q.Prompt.Prompt()
+		// if there was a problem
+		if err != nil {
+			return err
+		}
+
+		// if there is a validate handler for this question
+		if q.Validate != nil {
+			// wait for a valid response
+			for invalid := q.Validate(ans); invalid != nil; invalid = q.Validate(ans) {
+				err := q.Prompt.Error(invalid)
+				// if there was a problem
+				if err != nil {
+					return err
+				}
+
+				// ask for more input
+				ans, err = q.Prompt.Prompt()
+				// if there was a problem
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		if q.Transform != nil {
+			// check if we have a transformer available, if so
+			// then try to acquire the new representation of the
+			// answer, if the resulting answer is not nil.
+			if newAns := q.Transform(ans); newAns != nil {
+				ans = newAns
+			}
+		}
+
+		// tell the prompt to cleanup with the validated value
+		q.Prompt.Cleanup(ans)
+
+		// if something went wrong
+		if err != nil {
+			// stop listening
+			return err
+		}
+
+		// add it to the map
+		err = core.WriteAnswer(response, q.Name, ans)
+		// if something went wrong
+		if err != nil {
+			return err
+		}
+
+	}
+
+	// return the response
+	return nil
+}
+
+// paginate returns a single page of choices given the page size, the total list of
+// possible choices, and the current selected index in the total list.
+func paginate(page int, choices []string, sel int) ([]string, int) {
+	// the number of elements to show in a single page
+	var pageSize int
+	// if the select has a specific page size
+	if page != 0 {
+		// use the specified one
+		pageSize = page
+		// otherwise the select does not have a page size
+	} else {
+		// use the package default
+		pageSize = PageSize
+	}
+
+	var start, end, cursor int
+
+	if len(choices) < pageSize {
+		// if we dont have enough options to fill a page
+		start = 0
+		end = len(choices)
+		cursor = sel
+
+	} else if sel < pageSize/2 {
+		// if we are in the first half page
+		start = 0
+		end = pageSize
+		cursor = sel
+
+	} else if len(choices)-sel-1 < pageSize/2 {
+		// if we are in the last half page
+		start = len(choices) - pageSize
+		end = len(choices)
+		cursor = sel - start
+
+	} else {
+		// somewhere in the middle
+		above := pageSize / 2
+		below := pageSize - above
+
+		cursor = pageSize / 2
+		start = sel - above
+		end = sel + below
+	}
+
+	// return the subset we care about and the index
+	return choices[start:end], cursor
+}

vendor/github.com/AlecAivazis/survey/transform.go

@@ -0,0 +1,76 @@
+package survey
+
+import (
+	"reflect"
+	"strings"
+)
+
+// TransformString returns a `Transformer` based on the "f"
+// function which accepts a string representation of the answer
+// and returns a new one, transformed, answer.
+// Take for example the functions inside the std `strings` package,
+// they can be converted to a compatible `Transformer` by using this function,
+// i.e: `TransformString(strings.Title)`, `TransformString(strings.ToUpper)`.
+//
+// Note that `TransformString` is just a helper, `Transformer` can be used
+// to transform any type of answer.
+func TransformString(f func(s string) string) Transformer {
+	return func(ans interface{}) interface{} {
+		// if the answer value passed in is the zero value of the appropriate type
+		if isZero(reflect.ValueOf(ans)) {
+			// skip this `Transformer` by returning a nil value.
+			// The original answer will be not affected,
+			// see survey.go#L125.
+			return nil
+		}
+
+		// "ans" is never nil here, so we don't have to check that
+		// see survey.go#L97 for more.
+		// Make sure that the the answer's value was a typeof string.
+		s, ok := ans.(string)
+		if !ok {
+			return nil
+		}
+
+		return f(s)
+	}
+}
+
+// ToLower is a `Transformer`.
+// It receives an answer value
+// and returns a copy of the "ans"
+// with all Unicode letters mapped to their lower case.
+//
+// Note that if "ans" is not a string then it will
+// return a nil value, meaning that the above answer
+// will not be affected by this call at all.
+func ToLower(ans interface{}) interface{} {
+	transformer := TransformString(strings.ToLower)
+	return transformer(ans)
+}
+
+// Title is a `Transformer`.
+// It receives an answer value
+// and returns a copy of the "ans"
+// with all Unicode letters that begin words
+// mapped to their title case.
+//
+// Note that if "ans" is not a string then it will
+// return a nil value, meaning that the above answer
+// will not be affected by this call at all.
+func Title(ans interface{}) interface{} {
+	transformer := TransformString(strings.Title)
+	return transformer(ans)
+}
+
+// ComposeTransformers is a variadic function used to create one transformer from many.
+func ComposeTransformers(transformers ...Transformer) Transformer {
+	// return a transformer that calls each one sequentially
+	return func(ans interface{}) interface{} {
+		// execute each transformer
+		for _, t := range transformers {
+			ans = t(ans)
+		}
+		return ans
+	}
+}

vendor/github.com/AlecAivazis/survey/validate.go

@@ -0,0 +1,87 @@
+package survey
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// Required does not allow an empty value
+func Required(val interface{}) error {
+	// the reflect value of the result
+	value := reflect.ValueOf(val)
+
+	// if the value passed in is the zero value of the appropriate type
+	if isZero(value) && value.Kind() != reflect.Bool {
+		return errors.New("Value is required")
+	}
+	return nil
+}
+
+// MaxLength requires that the string is no longer than the specified value
+func MaxLength(length int) Validator {
+	// return a validator that checks the length of the string
+	return func(val interface{}) error {
+		if str, ok := val.(string); ok {
+			// if the string is longer than the given value
+			if len([]rune(str)) > length {
+				// yell loudly
+				return fmt.Errorf("value is too long. Max length is %v", length)
+			}
+		} else {
+			// otherwise we cannot convert the value into a string and cannot enforce length
+			return fmt.Errorf("cannot enforce length on response of type %v", reflect.TypeOf(val).Name())
+		}
+
+		// the input is fine
+		return nil
+	}
+}
+
+// MinLength requires that the string is longer or equal in length to the specified value
+func MinLength(length int) Validator {
+	// return a validator that checks the length of the string
+	return func(val interface{}) error {
+		if str, ok := val.(string); ok {
+			// if the string is shorter than the given value
+			if len([]rune(str)) < length {
+				// yell loudly
+				return fmt.Errorf("value is too short. Min length is %v", length)
+			}
+		} else {
+			// otherwise we cannot convert the value into a string and cannot enforce length
+			return fmt.Errorf("cannot enforce length on response of type %v", reflect.TypeOf(val).Name())
+		}
+
+		// the input is fine
+		return nil
+	}
+}
+
+// ComposeValidators is a variadic function used to create one validator from many.
+func ComposeValidators(validators ...Validator) Validator {
+	// return a validator that calls each one sequentially
+	return func(val interface{}) error {
+		// execute each validator
+		for _, validator := range validators {
+			// if the answer's value is not valid
+			if err := validator(val); err != nil {
+				// return the error
+				return err
+			}
+		}
+		// we passed all validators, the answer is valid
+		return nil
+	}
+}
+
+// isZero returns true if the passed value is the zero object
+func isZero(v reflect.Value) bool {
+	switch v.Kind() {
+	case reflect.Slice, reflect.Map:
+		return v.Len() == 0
+	}
+
+	// compare the types directly with more general coverage
+	return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface())
+}

vendor/github.com/AndreasBriese/bbloom/BUILD.bazel

@@ -0,0 +1,26 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "bbloom.go",
+        "sipHash.go",
+    ],
+    importmap = "go-common/vendor/github.com/AndreasBriese/bbloom",
+    importpath = "github.com/AndreasBriese/bbloom",
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/AndreasBriese/bbloom/LICENSE

@@ -0,0 +1,35 @@
+bbloom.go
+
+// The MIT License (MIT)
+// Copyright (c) 2014 Andreas Briese, eduToolbox@Bri-C GmbH, Sarstedt
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+siphash.go 
+
+// https://github.com/dchest/siphash
+//
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+//
+// Package siphash implements SipHash-2-4, a fast short-input PRF
+// created by Jean-Philippe Aumasson and Daniel J. Bernstein.

vendor/github.com/AndreasBriese/bbloom/README.md

@@ -0,0 +1,129 @@
+## bbloom: a bitset Bloom filter for go/golang
+===
+
+package implements a fast bloom filter with real 'bitset' and JSONMarshal/JSONUnmarshal to store/reload the Bloom filter. 
+
+NOTE: the package uses unsafe.Pointer to set and read the bits from the bitset. If you're uncomfortable with using the unsafe package, please consider using my bloom filter package at github.com/AndreasBriese/bloom
+
+===
+
+changelog 11/2015: new thread safe methods AddTS(), HasTS(), AddIfNotHasTS() following a suggestion from Srdjan Marinovic (github @a-little-srdjan), who used this to code a bloomfilter cache.  
+
+This bloom filter was developed to strengthen a website-log database and was tested and optimized for this log-entry mask: "2014/%02i/%02i %02i:%02i:%02i /info.html". 
+Nonetheless bbloom should work with any other form of entries. 
+
+~~Hash function is a modified Berkeley DB sdbm hash (to optimize for smaller strings). sdbm  http://www.cse.yorku.ca/~oz/hash.html~~
+
+Found sipHash (SipHash-2-4, a fast short-input PRF created by Jean-Philippe Aumasson and Daniel J. Bernstein.) to be about as fast. sipHash had been ported by Dimtry Chestnyk to Go (github.com/dchest/siphash )
+
+Minimum hashset size is: 512 ([4]uint64; will be set automatically). 
+
+###install
+
+```sh
+go get github.com/AndreasBriese/bbloom
+```
+
+###test
++ change to folder ../bbloom 
++ create wordlist in file "words.txt" (you might use `python permut.py`)
++ run 'go test -bench=.' within the folder
+
+```go
+go test -bench=.
+```
+
+~~If you've installed the GOCONVEY TDD-framework http://goconvey.co/ you can run the tests automatically.~~
+
+using go's testing framework now (have in mind that the op timing is related to 65536 operations of Add, Has, AddIfNotHas respectively)
+
+### usage
+
+after installation add
+
+```go
+import (
+	...
+	"github.com/AndreasBriese/bbloom"
+	...
+	)
+```
+
+at your header. In the program use
+
+```go
+// create a bloom filter for 65536 items and 1 % wrong-positive ratio 
+bf := bbloom.New(float64(1<<16), float64(0.01))
+
+// or 
+// create a bloom filter with 650000 for 65536 items and 7 locs per hash explicitly
+// bf = bbloom.New(float64(650000), float64(7))
+// or
+bf = bbloom.New(650000.0, 7.0)
+
+// add one item
+bf.Add([]byte("butter"))
+
+// Number of elements added is exposed now 
+// Note: ElemNum will not be included in JSON export (for compatability to older version)
+nOfElementsInFilter := bf.ElemNum
+
+// check if item is in the filter
+isIn := bf.Has([]byte("butter"))    // should be true
+isNotIn := bf.Has([]byte("Butter")) // should be false
+
+// 'add only if item is new' to the bloomfilter
+added := bf.AddIfNotHas([]byte("butter"))    // should be false because 'butter' is already in the set
+added = bf.AddIfNotHas([]byte("buTTer"))    // should be true because 'buTTer' is new
+
+// thread safe versions for concurrent use: AddTS, HasTS, AddIfNotHasTS
+// add one item
+bf.AddTS([]byte("peanutbutter"))
+// check if item is in the filter
+isIn = bf.HasTS([]byte("peanutbutter"))    // should be true
+isNotIn = bf.HasTS([]byte("peanutButter")) // should be false
+// 'add only if item is new' to the bloomfilter
+added = bf.AddIfNotHasTS([]byte("butter"))    // should be false because 'peanutbutter' is already in the set
+added = bf.AddIfNotHasTS([]byte("peanutbuTTer"))    // should be true because 'penutbuTTer' is new
+
+// convert to JSON ([]byte) 
+Json := bf.JSONMarshal()
+
+// bloomfilters Mutex is exposed for external un-/locking
+// i.e. mutex lock while doing JSON conversion
+bf.Mtx.Lock()
+Json = bf.JSONMarshal()
+bf.Mtx.Unlock()
+
+// restore a bloom filter from storage 
+bfNew := bbloom.JSONUnmarshal(Json)
+
+isInNew := bfNew.Has([]byte("butter"))    // should be true
+isNotInNew := bfNew.Has([]byte("Butter")) // should be false
+
+```
+
+to work with the bloom filter.
+
+### why 'fast'? 
+
+It's about 3 times faster than William Fitzgeralds bitset bloom filter https://github.com/willf/bloom . And it is about so fast as my []bool set variant for Boom filters (see https://github.com/AndreasBriese/bloom ) but having a 8times smaller memory footprint: 
+
+	
+	Bloom filter (filter size 524288, 7 hashlocs)
+	github.com/AndreasBriese/bbloom 'Add' 65536 items (10 repetitions): 6595800 ns (100 ns/op)
+    github.com/AndreasBriese/bbloom 'Has' 65536 items (10 repetitions): 5986600 ns (91 ns/op)
+	github.com/AndreasBriese/bloom 'Add' 65536 items (10 repetitions): 6304684 ns (96 ns/op)
+	github.com/AndreasBriese/bloom 'Has' 65536 items (10 repetitions): 6568663 ns (100 ns/op)
+	
+	github.com/willf/bloom 'Add' 65536 items (10 repetitions): 24367224 ns (371 ns/op)
+	github.com/willf/bloom 'Test' 65536 items (10 repetitions): 21881142 ns (333 ns/op)
+	github.com/dataence/bloom/standard 'Add' 65536 items (10 repetitions): 23041644 ns (351 ns/op)
+	github.com/dataence/bloom/standard 'Check' 65536 items (10 repetitions): 19153133 ns (292 ns/op)
+	github.com/cabello/bloom 'Add' 65536 items (10 repetitions): 131921507 ns (2012 ns/op)
+	github.com/cabello/bloom 'Contains' 65536 items (10 repetitions): 131108962 ns (2000 ns/op)
+
+(on MBPro15 OSX10.8.5 i7 4Core 2.4Ghz)
+
+
+With 32bit bloom filters (bloom32) using modified sdbm, bloom32 does hashing with only 2 bit shifts, one xor and one substraction per byte. smdb is about as fast as fnv64a but gives less collisions with the dataset (see mask above). bloom.New(float64(10 * 1<<16),float64(7)) populated with 1<<16 random items from the dataset (see above) and tested against the rest results in less than 0.05% collisions.   

vendor/github.com/AndreasBriese/bbloom/bbloom.go

@@ -0,0 +1,270 @@
+// The MIT License (MIT)
+// Copyright (c) 2014 Andreas Briese, eduToolbox@Bri-C GmbH, Sarstedt
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package bbloom
+
+import (
+	"bytes"
+	"encoding/json"
+	"log"
+	"math"
+	"sync"
+	"unsafe"
+)
+
+// helper
+var mask = []uint8{1, 2, 4, 8, 16, 32, 64, 128}
+
+func getSize(ui64 uint64) (size uint64, exponent uint64) {
+	if ui64 < uint64(512) {
+		ui64 = uint64(512)
+	}
+	size = uint64(1)
+	for size < ui64 {
+		size <<= 1
+		exponent++
+	}
+	return size, exponent
+}
+
+func calcSizeByWrongPositives(numEntries, wrongs float64) (uint64, uint64) {
+	size := -1 * numEntries * math.Log(wrongs) / math.Pow(float64(0.69314718056), 2)
+	locs := math.Ceil(float64(0.69314718056) * size / numEntries)
+	return uint64(size), uint64(locs)
+}
+
+// New
+// returns a new bloomfilter
+func New(params ...float64) (bloomfilter Bloom) {
+	var entries, locs uint64
+	if len(params) == 2 {
+		if params[1] < 1 {
+			entries, locs = calcSizeByWrongPositives(params[0], params[1])
+		} else {
+			entries, locs = uint64(params[0]), uint64(params[1])
+		}
+	} else {
+		log.Fatal("usage: New(float64(number_of_entries), float64(number_of_hashlocations)) i.e. New(float64(1000), float64(3)) or New(float64(number_of_entries), float64(number_of_hashlocations)) i.e. New(float64(1000), float64(0.03))")
+	}
+	size, exponent := getSize(uint64(entries))
+	bloomfilter = Bloom{
+		sizeExp: exponent,
+		size:    size - 1,
+		setLocs: locs,
+		shift:   64 - exponent,
+	}
+	bloomfilter.Size(size)
+	return bloomfilter
+}
+
+// NewWithBoolset
+// takes a []byte slice and number of locs per entry
+// returns the bloomfilter with a bitset populated according to the input []byte
+func NewWithBoolset(bs *[]byte, locs uint64) (bloomfilter Bloom) {
+	bloomfilter = New(float64(len(*bs)<<3), float64(locs))
+	ptr := uintptr(unsafe.Pointer(&bloomfilter.bitset[0]))
+	for _, b := range *bs {
+		*(*uint8)(unsafe.Pointer(ptr)) = b
+		ptr++
+	}
+	return bloomfilter
+}
+
+// bloomJSONImExport
+// Im/Export structure used by JSONMarshal / JSONUnmarshal
+type bloomJSONImExport struct {
+	FilterSet []byte
+	SetLocs   uint64
+}
+
+// JSONUnmarshal
+// takes JSON-Object (type bloomJSONImExport) as []bytes
+// returns bloom32 / bloom64 object
+func JSONUnmarshal(dbData []byte) Bloom {
+	bloomImEx := bloomJSONImExport{}
+	json.Unmarshal(dbData, &bloomImEx)
+	buf := bytes.NewBuffer(bloomImEx.FilterSet)
+	bs := buf.Bytes()
+	bf := NewWithBoolset(&bs, bloomImEx.SetLocs)
+	return bf
+}
+
+//
+// Bloom filter
+type Bloom struct {
+	Mtx     sync.Mutex
+	ElemNum uint64
+	bitset  []uint64
+	sizeExp uint64
+	size    uint64
+	setLocs uint64
+	shift   uint64
+}
+
+// <--- http://www.cse.yorku.ca/~oz/hash.html
+// modified Berkeley DB Hash (32bit)
+// hash is casted to l, h = 16bit fragments
+// func (bl Bloom) absdbm(b *[]byte) (l, h uint64) {
+// 	hash := uint64(len(*b))
+// 	for _, c := range *b {
+// 		hash = uint64(c) + (hash << 6) + (hash << bl.sizeExp) - hash
+// 	}
+// 	h = hash >> bl.shift
+// 	l = hash << bl.shift >> bl.shift
+// 	return l, h
+// }
+
+// Update: found sipHash of Jean-Philippe Aumasson & Daniel J. Bernstein to be even faster than absdbm()
+// https://131002.net/siphash/
+// siphash was implemented for Go by Dmitry Chestnykh https://github.com/dchest/siphash
+
+// Add
+// set the bit(s) for entry; Adds an entry to the Bloom filter
+func (bl *Bloom) Add(entry []byte) {
+	l, h := bl.sipHash(entry)
+	for i := uint64(0); i < (*bl).setLocs; i++ {
+		(*bl).Set((h + i*l) & (*bl).size)
+		(*bl).ElemNum++
+	}
+}
+
+// AddTS
+// Thread safe: Mutex.Lock the bloomfilter for the time of processing the entry
+func (bl *Bloom) AddTS(entry []byte) {
+	bl.Mtx.Lock()
+	defer bl.Mtx.Unlock()
+	bl.Add(entry[:])
+}
+
+// Has
+// check if bit(s) for entry is/are set
+// returns true if the entry was added to the Bloom Filter
+func (bl Bloom) Has(entry []byte) bool {
+	l, h := bl.sipHash(entry)
+	for i := uint64(0); i < bl.setLocs; i++ {
+		switch bl.IsSet((h + i*l) & bl.size) {
+		case false:
+			return false
+		}
+	}
+	return true
+}
+
+// HasTS
+// Thread safe: Mutex.Lock the bloomfilter for the time of processing the entry
+func (bl *Bloom) HasTS(entry []byte) bool {
+	bl.Mtx.Lock()
+	defer bl.Mtx.Unlock()
+	return bl.Has(entry[:])
+}
+
+// AddIfNotHas
+// Only Add entry if it's not present in the bloomfilter
+// returns true if entry was added
+// returns false if entry was allready registered in the bloomfilter
+func (bl Bloom) AddIfNotHas(entry []byte) (added bool) {
+	if bl.Has(entry[:]) {
+		return added
+	}
+	bl.Add(entry[:])
+	return true
+}
+
+// AddIfNotHasTS
+// Tread safe: Only Add entry if it's not present in the bloomfilter
+// returns true if entry was added
+// returns false if entry was allready registered in the bloomfilter
+func (bl *Bloom) AddIfNotHasTS(entry []byte) (added bool) {
+	bl.Mtx.Lock()
+	defer bl.Mtx.Unlock()
+	return bl.AddIfNotHas(entry[:])
+}
+
+// Size
+// make Bloom filter with as bitset of size sz
+func (bl *Bloom) Size(sz uint64) {
+	(*bl).bitset = make([]uint64, sz>>6)
+}
+
+// Clear
+// resets the Bloom filter
+func (bl *Bloom) Clear() {
+	for i, _ := range (*bl).bitset {
+		(*bl).bitset[i] = 0
+	}
+}
+
+// Set
+// set the bit[idx] of bitsit
+func (bl *Bloom) Set(idx uint64) {
+	ptr := unsafe.Pointer(uintptr(unsafe.Pointer(&bl.bitset[idx>>6])) + uintptr((idx%64)>>3))
+	*(*uint8)(ptr) |= mask[idx%8]
+}
+
+// IsSet
+// check if bit[idx] of bitset is set
+// returns true/false
+func (bl *Bloom) IsSet(idx uint64) bool {
+	ptr := unsafe.Pointer(uintptr(unsafe.Pointer(&bl.bitset[idx>>6])) + uintptr((idx%64)>>3))
+	r := ((*(*uint8)(ptr)) >> (idx % 8)) & 1
+	return r == 1
+}
+
+// JSONMarshal
+// returns JSON-object (type bloomJSONImExport) as []byte
+func (bl Bloom) JSONMarshal() []byte {
+	bloomImEx := bloomJSONImExport{}
+	bloomImEx.SetLocs = uint64(bl.setLocs)
+	bloomImEx.FilterSet = make([]byte, len(bl.bitset)<<3)
+	ptr := uintptr(unsafe.Pointer(&bl.bitset[0]))
+	for i := range bloomImEx.FilterSet {
+		bloomImEx.FilterSet[i] = *(*byte)(unsafe.Pointer(ptr))
+		ptr++
+	}
+	data, err := json.Marshal(bloomImEx)
+	if err != nil {
+		log.Fatal("json.Marshal failed: ", err)
+	}
+	return data
+}
+
+// // alternative hashFn
+// func (bl Bloom) fnv64a(b *[]byte) (l, h uint64) {
+// 	h64 := fnv.New64a()
+// 	h64.Write(*b)
+// 	hash := h64.Sum64()
+// 	h = hash >> 32
+// 	l = hash << 32 >> 32
+// 	return l, h
+// }
+//
+// // <-- http://partow.net/programming/hashfunctions/index.html
+// // citation: An algorithm proposed by Donald E. Knuth in The Art Of Computer Programming Volume 3,
+// // under the topic of sorting and search chapter 6.4.
+// // modified to fit with boolset-length
+// func (bl Bloom) DEKHash(b *[]byte) (l, h uint64) {
+// 	hash := uint64(len(*b))
+// 	for _, c := range *b {
+// 		hash = ((hash << 5) ^ (hash >> bl.shift)) ^ uint64(c)
+// 	}
+// 	h = hash >> bl.shift
+// 	l = hash << bl.sizeExp >> bl.sizeExp
+// 	return l, h
+// }

vendor/github.com/AndreasBriese/bbloom/sipHash.go

@@ -0,0 +1,225 @@
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+//
+// Package siphash implements SipHash-2-4, a fast short-input PRF
+// created by Jean-Philippe Aumasson and Daniel J. Bernstein.
+
+package bbloom
+
+// Hash returns the 64-bit SipHash-2-4 of the given byte slice with two 64-bit
+// parts of 128-bit key: k0 and k1.
+func (bl Bloom) sipHash(p []byte) (l, h uint64) {
+	// Initialization.
+	v0 := uint64(8317987320269560794) // k0 ^ 0x736f6d6570736575
+	v1 := uint64(7237128889637516672) // k1 ^ 0x646f72616e646f6d
+	v2 := uint64(7816392314733513934) // k0 ^ 0x6c7967656e657261
+	v3 := uint64(8387220255325274014) // k1 ^ 0x7465646279746573
+	t := uint64(len(p)) << 56
+
+	// Compression.
+	for len(p) >= 8 {
+
+		m := uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 |
+			uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
+
+		v3 ^= m
+
+		// Round 1.
+		v0 += v1
+		v1 = v1<<13 | v1>>51
+		v1 ^= v0
+		v0 = v0<<32 | v0>>32
+
+		v2 += v3
+		v3 = v3<<16 | v3>>48
+		v3 ^= v2
+
+		v0 += v3
+		v3 = v3<<21 | v3>>43
+		v3 ^= v0
+
+		v2 += v1
+		v1 = v1<<17 | v1>>47
+		v1 ^= v2
+		v2 = v2<<32 | v2>>32
+
+		// Round 2.
+		v0 += v1
+		v1 = v1<<13 | v1>>51
+		v1 ^= v0
+		v0 = v0<<32 | v0>>32
+
+		v2 += v3
+		v3 = v3<<16 | v3>>48
+		v3 ^= v2
+
+		v0 += v3
+		v3 = v3<<21 | v3>>43
+		v3 ^= v0
+
+		v2 += v1
+		v1 = v1<<17 | v1>>47
+		v1 ^= v2
+		v2 = v2<<32 | v2>>32
+
+		v0 ^= m
+		p = p[8:]
+	}
+
+	// Compress last block.
+	switch len(p) {
+	case 7:
+		t |= uint64(p[6]) << 48
+		fallthrough
+	case 6:
+		t |= uint64(p[5]) << 40
+		fallthrough
+	case 5:
+		t |= uint64(p[4]) << 32
+		fallthrough
+	case 4:
+		t |= uint64(p[3]) << 24
+		fallthrough
+	case 3:
+		t |= uint64(p[2]) << 16
+		fallthrough
+	case 2:
+		t |= uint64(p[1]) << 8
+		fallthrough
+	case 1:
+		t |= uint64(p[0])
+	}
+
+	v3 ^= t
+
+	// Round 1.
+	v0 += v1
+	v1 = v1<<13 | v1>>51
+	v1 ^= v0
+	v0 = v0<<32 | v0>>32
+
+	v2 += v3
+	v3 = v3<<16 | v3>>48
+	v3 ^= v2
+
+	v0 += v3
+	v3 = v3<<21 | v3>>43
+	v3 ^= v0
+
+	v2 += v1
+	v1 = v1<<17 | v1>>47
+	v1 ^= v2
+	v2 = v2<<32 | v2>>32
+
+	// Round 2.
+	v0 += v1
+	v1 = v1<<13 | v1>>51
+	v1 ^= v0
+	v0 = v0<<32 | v0>>32
+
+	v2 += v3
+	v3 = v3<<16 | v3>>48
+	v3 ^= v2
+
+	v0 += v3
+	v3 = v3<<21 | v3>>43
+	v3 ^= v0
+
+	v2 += v1
+	v1 = v1<<17 | v1>>47
+	v1 ^= v2
+	v2 = v2<<32 | v2>>32
+
+	v0 ^= t
+
+	// Finalization.
+	v2 ^= 0xff
+
+	// Round 1.
+	v0 += v1
+	v1 = v1<<13 | v1>>51
+	v1 ^= v0
+	v0 = v0<<32 | v0>>32
+
+	v2 += v3
+	v3 = v3<<16 | v3>>48
+	v3 ^= v2
+
+	v0 += v3
+	v3 = v3<<21 | v3>>43
+	v3 ^= v0
+
+	v2 += v1
+	v1 = v1<<17 | v1>>47
+	v1 ^= v2
+	v2 = v2<<32 | v2>>32
+
+	// Round 2.
+	v0 += v1
+	v1 = v1<<13 | v1>>51
+	v1 ^= v0
+	v0 = v0<<32 | v0>>32
+
+	v2 += v3
+	v3 = v3<<16 | v3>>48
+	v3 ^= v2
+
+	v0 += v3
+	v3 = v3<<21 | v3>>43
+	v3 ^= v0
+
+	v2 += v1
+	v1 = v1<<17 | v1>>47
+	v1 ^= v2
+	v2 = v2<<32 | v2>>32
+
+	// Round 3.
+	v0 += v1
+	v1 = v1<<13 | v1>>51
+	v1 ^= v0
+	v0 = v0<<32 | v0>>32
+
+	v2 += v3
+	v3 = v3<<16 | v3>>48
+	v3 ^= v2
+
+	v0 += v3
+	v3 = v3<<21 | v3>>43
+	v3 ^= v0
+
+	v2 += v1
+	v1 = v1<<17 | v1>>47
+	v1 ^= v2
+	v2 = v2<<32 | v2>>32
+
+	// Round 4.
+	v0 += v1
+	v1 = v1<<13 | v1>>51
+	v1 ^= v0
+	v0 = v0<<32 | v0>>32
+
+	v2 += v3
+	v3 = v3<<16 | v3>>48
+	v3 ^= v2
+
+	v0 += v3
+	v3 = v3<<21 | v3>>43
+	v3 ^= v0
+
+	v2 += v1
+	v1 = v1<<17 | v1>>47
+	v1 ^= v2
+	v2 = v2<<32 | v2>>32
+
+	// return v0 ^ v1 ^ v2 ^ v3
+
+	hash := v0 ^ v1 ^ v2 ^ v3
+	h = hash >> bl.shift
+	l = hash << bl.shift >> bl.shift
+	return l, h
+
+}

vendor/github.com/BurntSushi/toml/BUILD.bazel

@@ -0,0 +1,34 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "decode.go",
+        "decode_meta.go",
+        "doc.go",
+        "encode.go",
+        "encoding_types.go",
+        "encoding_types_1.1.go",
+        "lex.go",
+        "parse.go",
+        "type_check.go",
+        "type_fields.go",
+    ],
+    importmap = "go-common/vendor/github.com/BurntSushi/toml",
+    importpath = "github.com/BurntSushi/toml",
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/BurntSushi/toml/COMPATIBLE

@@ -0,0 +1,3 @@
+Compatible with TOML version
+[v0.4.0](https://github.com/toml-lang/toml/blob/v0.4.0/versions/en/toml-v0.4.0.md)
+

vendor/github.com/BurntSushi/toml/COPYING

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 TOML authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/BurntSushi/toml/Makefile

@@ -0,0 +1,19 @@
+install:
+	go install ./...
+
+test: install
+	go test -v
+	toml-test toml-test-decoder
+	toml-test -encoder toml-test-encoder
+
+fmt:
+	gofmt -w *.go */*.go
+	colcheck *.go */*.go
+
+tags:
+	find ./ -name '*.go' -print0 | xargs -0 gotags > TAGS
+
+push:
+	git push origin master
+	git push github master
+

vendor/github.com/BurntSushi/toml/README.md

@@ -0,0 +1,218 @@
+## TOML parser and encoder for Go with reflection
+
+TOML stands for Tom's Obvious, Minimal Language. This Go package provides a
+reflection interface similar to Go's standard library `json` and `xml`
+packages. This package also supports the `encoding.TextUnmarshaler` and
+`encoding.TextMarshaler` interfaces so that you can define custom data
+representations. (There is an example of this below.)
+
+Spec: https://github.com/toml-lang/toml
+
+Compatible with TOML version
+[v0.4.0](https://github.com/toml-lang/toml/blob/master/versions/en/toml-v0.4.0.md)
+
+Documentation: https://godoc.org/github.com/BurntSushi/toml
+
+Installation:
+
+```bash
+go get github.com/BurntSushi/toml
+```
+
+Try the toml validator:
+
+```bash
+go get github.com/BurntSushi/toml/cmd/tomlv
+tomlv some-toml-file.toml
+```
+
+[![Build Status](https://travis-ci.org/BurntSushi/toml.svg?branch=master)](https://travis-ci.org/BurntSushi/toml) [![GoDoc](https://godoc.org/github.com/BurntSushi/toml?status.svg)](https://godoc.org/github.com/BurntSushi/toml)
+
+### Testing
+
+This package passes all tests in
+[toml-test](https://github.com/BurntSushi/toml-test) for both the decoder
+and the encoder.
+
+### Examples
+
+This package works similarly to how the Go standard library handles `XML`
+and `JSON`. Namely, data is loaded into Go values via reflection.
+
+For the simplest example, consider some TOML file as just a list of keys
+and values:
+
+```toml
+Age = 25
+Cats = [ "Cauchy", "Plato" ]
+Pi = 3.14
+Perfection = [ 6, 28, 496, 8128 ]
+DOB = 1987-07-05T05:45:00Z
+```
+
+Which could be defined in Go as:
+
+```go
+type Config struct {
+  Age int
+  Cats []string
+  Pi float64
+  Perfection []int
+  DOB time.Time // requires `import time`
+}
+```
+
+And then decoded with:
+
+```go
+var conf Config
+if _, err := toml.Decode(tomlData, &conf); err != nil {
+  // handle error
+}
+```
+
+You can also use struct tags if your struct field name doesn't map to a TOML
+key value directly:
+
+```toml
+some_key_NAME = "wat"
+```
+
+```go
+type TOML struct {
+  ObscureKey string `toml:"some_key_NAME"`
+}
+```
+
+### Using the `encoding.TextUnmarshaler` interface
+
+Here's an example that automatically parses duration strings into
+`time.Duration` values:
+
+```toml
+[[song]]
+name = "Thunder Road"
+duration = "4m49s"
+
+[[song]]
+name = "Stairway to Heaven"
+duration = "8m03s"
+```
+
+Which can be decoded with:
+
+```go
+type song struct {
+  Name     string
+  Duration duration
+}
+type songs struct {
+  Song []song
+}
+var favorites songs
+if _, err := toml.Decode(blob, &favorites); err != nil {
+  log.Fatal(err)
+}
+
+for _, s := range favorites.Song {
+  fmt.Printf("%s (%s)\n", s.Name, s.Duration)
+}
+```
+
+And you'll also need a `duration` type that satisfies the
+`encoding.TextUnmarshaler` interface:
+
+```go
+type duration struct {
+	time.Duration
+}
+
+func (d *duration) UnmarshalText(text []byte) error {
+	var err error
+	d.Duration, err = time.ParseDuration(string(text))
+	return err
+}
+```
+
+### More complex usage
+
+Here's an example of how to load the example from the official spec page:
+
+```toml
+# This is a TOML document. Boom.
+
+title = "TOML Example"
+
+[owner]
+name = "Tom Preston-Werner"
+organization = "GitHub"
+bio = "GitHub Cofounder & CEO\nLikes tater tots and beer."
+dob = 1979-05-27T07:32:00Z # First class dates? Why not?
+
+[database]
+server = "192.168.1.1"
+ports = [ 8001, 8001, 8002 ]
+connection_max = 5000
+enabled = true
+
+[servers]
+
+  # You can indent as you please. Tabs or spaces. TOML don't care.
+  [servers.alpha]
+  ip = "10.0.0.1"
+  dc = "eqdc10"
+
+  [servers.beta]
+  ip = "10.0.0.2"
+  dc = "eqdc10"
+
+[clients]
+data = [ ["gamma", "delta"], [1, 2] ] # just an update to make sure parsers support it
+
+# Line breaks are OK when inside arrays
+hosts = [
+  "alpha",
+  "omega"
+]
+```
+
+And the corresponding Go types are:
+
+```go
+type tomlConfig struct {
+	Title string
+	Owner ownerInfo
+	DB database `toml:"database"`
+	Servers map[string]server
+	Clients clients
+}
+
+type ownerInfo struct {
+	Name string
+	Org string `toml:"organization"`
+	Bio string
+	DOB time.Time
+}
+
+type database struct {
+	Server string
+	Ports []int
+	ConnMax int `toml:"connection_max"`
+	Enabled bool
+}
+
+type server struct {
+	IP string
+	DC string
+}
+
+type clients struct {
+	Data [][]interface{}
+	Hosts []string
+}
+```
+
+Note that a case insensitive match will be tried if an exact match can't be
+found.
+
+A working example of the above can be found in `_examples/example.{go,toml}`.

vendor/github.com/BurntSushi/toml/decode.go

@@ -0,0 +1,509 @@
+package toml
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"reflect"
+	"strings"
+	"time"
+)
+
+func e(format string, args ...interface{}) error {
+	return fmt.Errorf("toml: "+format, args...)
+}
+
+// Unmarshaler is the interface implemented by objects that can unmarshal a
+// TOML description of themselves.
+type Unmarshaler interface {
+	UnmarshalTOML(interface{}) error
+}
+
+// Unmarshal decodes the contents of `p` in TOML format into a pointer `v`.
+func Unmarshal(p []byte, v interface{}) error {
+	_, err := Decode(string(p), v)
+	return err
+}
+
+// Primitive is a TOML value that hasn't been decoded into a Go value.
+// When using the various `Decode*` functions, the type `Primitive` may
+// be given to any value, and its decoding will be delayed.
+//
+// A `Primitive` value can be decoded using the `PrimitiveDecode` function.
+//
+// The underlying representation of a `Primitive` value is subject to change.
+// Do not rely on it.
+//
+// N.B. Primitive values are still parsed, so using them will only avoid
+// the overhead of reflection. They can be useful when you don't know the
+// exact type of TOML data until run time.
+type Primitive struct {
+	undecoded interface{}
+	context   Key
+}
+
+// DEPRECATED!
+//
+// Use MetaData.PrimitiveDecode instead.
+func PrimitiveDecode(primValue Primitive, v interface{}) error {
+	md := MetaData{decoded: make(map[string]bool)}
+	return md.unify(primValue.undecoded, rvalue(v))
+}
+
+// PrimitiveDecode is just like the other `Decode*` functions, except it
+// decodes a TOML value that has already been parsed. Valid primitive values
+// can *only* be obtained from values filled by the decoder functions,
+// including this method. (i.e., `v` may contain more `Primitive`
+// values.)
+//
+// Meta data for primitive values is included in the meta data returned by
+// the `Decode*` functions with one exception: keys returned by the Undecoded
+// method will only reflect keys that were decoded. Namely, any keys hidden
+// behind a Primitive will be considered undecoded. Executing this method will
+// update the undecoded keys in the meta data. (See the example.)
+func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {
+	md.context = primValue.context
+	defer func() { md.context = nil }()
+	return md.unify(primValue.undecoded, rvalue(v))
+}
+
+// Decode will decode the contents of `data` in TOML format into a pointer
+// `v`.
+//
+// TOML hashes correspond to Go structs or maps. (Dealer's choice. They can be
+// used interchangeably.)
+//
+// TOML arrays of tables correspond to either a slice of structs or a slice
+// of maps.
+//
+// TOML datetimes correspond to Go `time.Time` values.
+//
+// All other TOML types (float, string, int, bool and array) correspond
+// to the obvious Go types.
+//
+// An exception to the above rules is if a type implements the
+// encoding.TextUnmarshaler interface. In this case, any primitive TOML value
+// (floats, strings, integers, booleans and datetimes) will be converted to
+// a byte string and given to the value's UnmarshalText method. See the
+// Unmarshaler example for a demonstration with time duration strings.
+//
+// Key mapping
+//
+// TOML keys can map to either keys in a Go map or field names in a Go
+// struct. The special `toml` struct tag may be used to map TOML keys to
+// struct fields that don't match the key name exactly. (See the example.)
+// A case insensitive match to struct names will be tried if an exact match
+// can't be found.
+//
+// The mapping between TOML values and Go values is loose. That is, there
+// may exist TOML values that cannot be placed into your representation, and
+// there may be parts of your representation that do not correspond to
+// TOML values. This loose mapping can be made stricter by using the IsDefined
+// and/or Undecoded methods on the MetaData returned.
+//
+// This decoder will not handle cyclic types. If a cyclic type is passed,
+// `Decode` will not terminate.
+func Decode(data string, v interface{}) (MetaData, error) {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() != reflect.Ptr {
+		return MetaData{}, e("Decode of non-pointer %s", reflect.TypeOf(v))
+	}
+	if rv.IsNil() {
+		return MetaData{}, e("Decode of nil %s", reflect.TypeOf(v))
+	}
+	p, err := parse(data)
+	if err != nil {
+		return MetaData{}, err
+	}
+	md := MetaData{
+		p.mapping, p.types, p.ordered,
+		make(map[string]bool, len(p.ordered)), nil,
+	}
+	return md, md.unify(p.mapping, indirect(rv))
+}
+
+// DecodeFile is just like Decode, except it will automatically read the
+// contents of the file at `fpath` and decode it for you.
+func DecodeFile(fpath string, v interface{}) (MetaData, error) {
+	bs, err := ioutil.ReadFile(fpath)
+	if err != nil {
+		return MetaData{}, err
+	}
+	return Decode(string(bs), v)
+}
+
+// DecodeReader is just like Decode, except it will consume all bytes
+// from the reader and decode it for you.
+func DecodeReader(r io.Reader, v interface{}) (MetaData, error) {
+	bs, err := ioutil.ReadAll(r)
+	if err != nil {
+		return MetaData{}, err
+	}
+	return Decode(string(bs), v)
+}
+
+// unify performs a sort of type unification based on the structure of `rv`,
+// which is the client representation.
+//
+// Any type mismatch produces an error. Finding a type that we don't know
+// how to handle produces an unsupported type error.
+func (md *MetaData) unify(data interface{}, rv reflect.Value) error {
+
+	// Special case. Look for a `Primitive` value.
+	if rv.Type() == reflect.TypeOf((*Primitive)(nil)).Elem() {
+		// Save the undecoded data and the key context into the primitive
+		// value.
+		context := make(Key, len(md.context))
+		copy(context, md.context)
+		rv.Set(reflect.ValueOf(Primitive{
+			undecoded: data,
+			context:   context,
+		}))
+		return nil
+	}
+
+	// Special case. Unmarshaler Interface support.
+	if rv.CanAddr() {
+		if v, ok := rv.Addr().Interface().(Unmarshaler); ok {
+			return v.UnmarshalTOML(data)
+		}
+	}
+
+	// Special case. Handle time.Time values specifically.
+	// TODO: Remove this code when we decide to drop support for Go 1.1.
+	// This isn't necessary in Go 1.2 because time.Time satisfies the encoding
+	// interfaces.
+	if rv.Type().AssignableTo(rvalue(time.Time{}).Type()) {
+		return md.unifyDatetime(data, rv)
+	}
+
+	// Special case. Look for a value satisfying the TextUnmarshaler interface.
+	if v, ok := rv.Interface().(TextUnmarshaler); ok {
+		return md.unifyText(data, v)
+	}
+	// BUG(burntsushi)
+	// The behavior here is incorrect whenever a Go type satisfies the
+	// encoding.TextUnmarshaler interface but also corresponds to a TOML
+	// hash or array. In particular, the unmarshaler should only be applied
+	// to primitive TOML values. But at this point, it will be applied to
+	// all kinds of values and produce an incorrect error whenever those values
+	// are hashes or arrays (including arrays of tables).
+
+	k := rv.Kind()
+
+	// laziness
+	if k >= reflect.Int && k <= reflect.Uint64 {
+		return md.unifyInt(data, rv)
+	}
+	switch k {
+	case reflect.Ptr:
+		elem := reflect.New(rv.Type().Elem())
+		err := md.unify(data, reflect.Indirect(elem))
+		if err != nil {
+			return err
+		}
+		rv.Set(elem)
+		return nil
+	case reflect.Struct:
+		return md.unifyStruct(data, rv)
+	case reflect.Map:
+		return md.unifyMap(data, rv)
+	case reflect.Array:
+		return md.unifyArray(data, rv)
+	case reflect.Slice:
+		return md.unifySlice(data, rv)
+	case reflect.String:
+		return md.unifyString(data, rv)
+	case reflect.Bool:
+		return md.unifyBool(data, rv)
+	case reflect.Interface:
+		// we only support empty interfaces.
+		if rv.NumMethod() > 0 {
+			return e("unsupported type %s", rv.Type())
+		}
+		return md.unifyAnything(data, rv)
+	case reflect.Float32:
+		fallthrough
+	case reflect.Float64:
+		return md.unifyFloat64(data, rv)
+	}
+	return e("unsupported type %s", rv.Kind())
+}
+
+func (md *MetaData) unifyStruct(mapping interface{}, rv reflect.Value) error {
+	tmap, ok := mapping.(map[string]interface{})
+	if !ok {
+		if mapping == nil {
+			return nil
+		}
+		return e("type mismatch for %s: expected table but found %T",
+			rv.Type().String(), mapping)
+	}
+
+	for key, datum := range tmap {
+		var f *field
+		fields := cachedTypeFields(rv.Type())
+		for i := range fields {
+			ff := &fields[i]
+			if ff.name == key {
+				f = ff
+				break
+			}
+			if f == nil && strings.EqualFold(ff.name, key) {
+				f = ff
+			}
+		}
+		if f != nil {
+			subv := rv
+			for _, i := range f.index {
+				subv = indirect(subv.Field(i))
+			}
+			if isUnifiable(subv) {
+				md.decoded[md.context.add(key).String()] = true
+				md.context = append(md.context, key)
+				if err := md.unify(datum, subv); err != nil {
+					return err
+				}
+				md.context = md.context[0 : len(md.context)-1]
+			} else if f.name != "" {
+				// Bad user! No soup for you!
+				return e("cannot write unexported field %s.%s",
+					rv.Type().String(), f.name)
+			}
+		}
+	}
+	return nil
+}
+
+func (md *MetaData) unifyMap(mapping interface{}, rv reflect.Value) error {
+	tmap, ok := mapping.(map[string]interface{})
+	if !ok {
+		if tmap == nil {
+			return nil
+		}
+		return badtype("map", mapping)
+	}
+	if rv.IsNil() {
+		rv.Set(reflect.MakeMap(rv.Type()))
+	}
+	for k, v := range tmap {
+		md.decoded[md.context.add(k).String()] = true
+		md.context = append(md.context, k)
+
+		rvkey := indirect(reflect.New(rv.Type().Key()))
+		rvval := reflect.Indirect(reflect.New(rv.Type().Elem()))
+		if err := md.unify(v, rvval); err != nil {
+			return err
+		}
+		md.context = md.context[0 : len(md.context)-1]
+
+		rvkey.SetString(k)
+		rv.SetMapIndex(rvkey, rvval)
+	}
+	return nil
+}
+
+func (md *MetaData) unifyArray(data interface{}, rv reflect.Value) error {
+	datav := reflect.ValueOf(data)
+	if datav.Kind() != reflect.Slice {
+		if !datav.IsValid() {
+			return nil
+		}
+		return badtype("slice", data)
+	}
+	sliceLen := datav.Len()
+	if sliceLen != rv.Len() {
+		return e("expected array length %d; got TOML array of length %d",
+			rv.Len(), sliceLen)
+	}
+	return md.unifySliceArray(datav, rv)
+}
+
+func (md *MetaData) unifySlice(data interface{}, rv reflect.Value) error {
+	datav := reflect.ValueOf(data)
+	if datav.Kind() != reflect.Slice {
+		if !datav.IsValid() {
+			return nil
+		}
+		return badtype("slice", data)
+	}
+	n := datav.Len()
+	if rv.IsNil() || rv.Cap() < n {
+		rv.Set(reflect.MakeSlice(rv.Type(), n, n))
+	}
+	rv.SetLen(n)
+	return md.unifySliceArray(datav, rv)
+}
+
+func (md *MetaData) unifySliceArray(data, rv reflect.Value) error {
+	sliceLen := data.Len()
+	for i := 0; i < sliceLen; i++ {
+		v := data.Index(i).Interface()
+		sliceval := indirect(rv.Index(i))
+		if err := md.unify(v, sliceval); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (md *MetaData) unifyDatetime(data interface{}, rv reflect.Value) error {
+	if _, ok := data.(time.Time); ok {
+		rv.Set(reflect.ValueOf(data))
+		return nil
+	}
+	return badtype("time.Time", data)
+}
+
+func (md *MetaData) unifyString(data interface{}, rv reflect.Value) error {
+	if s, ok := data.(string); ok {
+		rv.SetString(s)
+		return nil
+	}
+	return badtype("string", data)
+}
+
+func (md *MetaData) unifyFloat64(data interface{}, rv reflect.Value) error {
+	if num, ok := data.(float64); ok {
+		switch rv.Kind() {
+		case reflect.Float32:
+			fallthrough
+		case reflect.Float64:
+			rv.SetFloat(num)
+		default:
+			panic("bug")
+		}
+		return nil
+	}
+	return badtype("float", data)
+}
+
+func (md *MetaData) unifyInt(data interface{}, rv reflect.Value) error {
+	if num, ok := data.(int64); ok {
+		if rv.Kind() >= reflect.Int && rv.Kind() <= reflect.Int64 {
+			switch rv.Kind() {
+			case reflect.Int, reflect.Int64:
+				// No bounds checking necessary.
+			case reflect.Int8:
+				if num < math.MinInt8 || num > math.MaxInt8 {
+					return e("value %d is out of range for int8", num)
+				}
+			case reflect.Int16:
+				if num < math.MinInt16 || num > math.MaxInt16 {
+					return e("value %d is out of range for int16", num)
+				}
+			case reflect.Int32:
+				if num < math.MinInt32 || num > math.MaxInt32 {
+					return e("value %d is out of range for int32", num)
+				}
+			}
+			rv.SetInt(num)
+		} else if rv.Kind() >= reflect.Uint && rv.Kind() <= reflect.Uint64 {
+			unum := uint64(num)
+			switch rv.Kind() {
+			case reflect.Uint, reflect.Uint64:
+				// No bounds checking necessary.
+			case reflect.Uint8:
+				if num < 0 || unum > math.MaxUint8 {
+					return e("value %d is out of range for uint8", num)
+				}
+			case reflect.Uint16:
+				if num < 0 || unum > math.MaxUint16 {
+					return e("value %d is out of range for uint16", num)
+				}
+			case reflect.Uint32:
+				if num < 0 || unum > math.MaxUint32 {
+					return e("value %d is out of range for uint32", num)
+				}
+			}
+			rv.SetUint(unum)
+		} else {
+			panic("unreachable")
+		}
+		return nil
+	}
+	return badtype("integer", data)
+}
+
+func (md *MetaData) unifyBool(data interface{}, rv reflect.Value) error {
+	if b, ok := data.(bool); ok {
+		rv.SetBool(b)
+		return nil
+	}
+	return badtype("boolean", data)
+}
+
+func (md *MetaData) unifyAnything(data interface{}, rv reflect.Value) error {
+	rv.Set(reflect.ValueOf(data))
+	return nil
+}
+
+func (md *MetaData) unifyText(data interface{}, v TextUnmarshaler) error {
+	var s string
+	switch sdata := data.(type) {
+	case TextMarshaler:
+		text, err := sdata.MarshalText()
+		if err != nil {
+			return err
+		}
+		s = string(text)
+	case fmt.Stringer:
+		s = sdata.String()
+	case string:
+		s = sdata
+	case bool:
+		s = fmt.Sprintf("%v", sdata)
+	case int64:
+		s = fmt.Sprintf("%d", sdata)
+	case float64:
+		s = fmt.Sprintf("%f", sdata)
+	default:
+		return badtype("primitive (string-like)", data)
+	}
+	if err := v.UnmarshalText([]byte(s)); err != nil {
+		return err
+	}
+	return nil
+}
+
+// rvalue returns a reflect.Value of `v`. All pointers are resolved.
+func rvalue(v interface{}) reflect.Value {
+	return indirect(reflect.ValueOf(v))
+}
+
+// indirect returns the value pointed to by a pointer.
+// Pointers are followed until the value is not a pointer.
+// New values are allocated for each nil pointer.
+//
+// An exception to this rule is if the value satisfies an interface of
+// interest to us (like encoding.TextUnmarshaler).
+func indirect(v reflect.Value) reflect.Value {
+	if v.Kind() != reflect.Ptr {
+		if v.CanSet() {
+			pv := v.Addr()
+			if _, ok := pv.Interface().(TextUnmarshaler); ok {
+				return pv
+			}
+		}
+		return v
+	}
+	if v.IsNil() {
+		v.Set(reflect.New(v.Type().Elem()))
+	}
+	return indirect(reflect.Indirect(v))
+}
+
+func isUnifiable(rv reflect.Value) bool {
+	if rv.CanSet() {
+		return true
+	}
+	if _, ok := rv.Interface().(TextUnmarshaler); ok {
+		return true
+	}
+	return false
+}
+
+func badtype(expected string, data interface{}) error {
+	return e("cannot load TOML value of type %T into a Go %s", data, expected)
+}

vendor/github.com/BurntSushi/toml/decode_meta.go

@@ -0,0 +1,121 @@
+package toml
+
+import "strings"
+
+// MetaData allows access to meta information about TOML data that may not
+// be inferrable via reflection. In particular, whether a key has been defined
+// and the TOML type of a key.
+type MetaData struct {
+	mapping map[string]interface{}
+	types   map[string]tomlType
+	keys    []Key
+	decoded map[string]bool
+	context Key // Used only during decoding.
+}
+
+// IsDefined returns true if the key given exists in the TOML data. The key
+// should be specified hierarchially. e.g.,
+//
+//	// access the TOML key 'a.b.c'
+//	IsDefined("a", "b", "c")
+//
+// IsDefined will return false if an empty key given. Keys are case sensitive.
+func (md *MetaData) IsDefined(key ...string) bool {
+	if len(key) == 0 {
+		return false
+	}
+
+	var hash map[string]interface{}
+	var ok bool
+	var hashOrVal interface{} = md.mapping
+	for _, k := range key {
+		if hash, ok = hashOrVal.(map[string]interface{}); !ok {
+			return false
+		}
+		if hashOrVal, ok = hash[k]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// Type returns a string representation of the type of the key specified.
+//
+// Type will return the empty string if given an empty key or a key that
+// does not exist. Keys are case sensitive.
+func (md *MetaData) Type(key ...string) string {
+	fullkey := strings.Join(key, ".")
+	if typ, ok := md.types[fullkey]; ok {
+		return typ.typeString()
+	}
+	return ""
+}
+
+// Key is the type of any TOML key, including key groups. Use (MetaData).Keys
+// to get values of this type.
+type Key []string
+
+func (k Key) String() string {
+	return strings.Join(k, ".")
+}
+
+func (k Key) maybeQuotedAll() string {
+	var ss []string
+	for i := range k {
+		ss = append(ss, k.maybeQuoted(i))
+	}
+	return strings.Join(ss, ".")
+}
+
+func (k Key) maybeQuoted(i int) string {
+	quote := false
+	for _, c := range k[i] {
+		if !isBareKeyChar(c) {
+			quote = true
+			break
+		}
+	}
+	if quote {
+		return "\"" + strings.Replace(k[i], "\"", "\\\"", -1) + "\""
+	}
+	return k[i]
+}
+
+func (k Key) add(piece string) Key {
+	newKey := make(Key, len(k)+1)
+	copy(newKey, k)
+	newKey[len(k)] = piece
+	return newKey
+}
+
+// Keys returns a slice of every key in the TOML data, including key groups.
+// Each key is itself a slice, where the first element is the top of the
+// hierarchy and the last is the most specific.
+//
+// The list will have the same order as the keys appeared in the TOML data.
+//
+// All keys returned are non-empty.
+func (md *MetaData) Keys() []Key {
+	return md.keys
+}
+
+// Undecoded returns all keys that have not been decoded in the order in which
+// they appear in the original TOML document.
+//
+// This includes keys that haven't been decoded because of a Primitive value.
+// Once the Primitive value is decoded, the keys will be considered decoded.
+//
+// Also note that decoding into an empty interface will result in no decoding,
+// and so no keys will be considered decoded.
+//
+// In this sense, the Undecoded keys correspond to keys in the TOML document
+// that do not have a concrete type in your representation.
+func (md *MetaData) Undecoded() []Key {
+	undecoded := make([]Key, 0, len(md.keys))
+	for _, key := range md.keys {
+		if !md.decoded[key.String()] {
+			undecoded = append(undecoded, key)
+		}
+	}
+	return undecoded
+}

vendor/github.com/BurntSushi/toml/doc.go

@@ -0,0 +1,27 @@
+/*
+Package toml provides facilities for decoding and encoding TOML configuration
+files via reflection. There is also support for delaying decoding with
+the Primitive type, and querying the set of keys in a TOML document with the
+MetaData type.
+
+The specification implemented: https://github.com/toml-lang/toml
+
+The sub-command github.com/BurntSushi/toml/cmd/tomlv can be used to verify
+whether a file is a valid TOML document. It can also be used to print the
+type of each key in a TOML document.
+
+Testing
+
+There are two important types of tests used for this package. The first is
+contained inside '*_test.go' files and uses the standard Go unit testing
+framework. These tests are primarily devoted to holistically testing the
+decoder and encoder.
+
+The second type of testing is used to verify the implementation's adherence
+to the TOML specification. These tests have been factored into their own
+project: https://github.com/BurntSushi/toml-test
+
+The reason the tests are in a separate project is so that they can be used by
+any implementation of TOML. Namely, it is language agnostic.
+*/
+package toml

vendor/github.com/BurntSushi/toml/encode.go

@@ -0,0 +1,568 @@
+package toml
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"io"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type tomlEncodeError struct{ error }
+
+var (
+	errArrayMixedElementTypes = errors.New(
+		"toml: cannot encode array with mixed element types")
+	errArrayNilElement = errors.New(
+		"toml: cannot encode array with nil element")
+	errNonString = errors.New(
+		"toml: cannot encode a map with non-string key type")
+	errAnonNonStruct = errors.New(
+		"toml: cannot encode an anonymous field that is not a struct")
+	errArrayNoTable = errors.New(
+		"toml: TOML array element cannot contain a table")
+	errNoKey = errors.New(
+		"toml: top-level values must be Go maps or structs")
+	errAnything = errors.New("") // used in testing
+)
+
+var quotedReplacer = strings.NewReplacer(
+	"\t", "\\t",
+	"\n", "\\n",
+	"\r", "\\r",
+	"\"", "\\\"",
+	"\\", "\\\\",
+)
+
+// Encoder controls the encoding of Go values to a TOML document to some
+// io.Writer.
+//
+// The indentation level can be controlled with the Indent field.
+type Encoder struct {
+	// A single indentation level. By default it is two spaces.
+	Indent string
+
+	// hasWritten is whether we have written any output to w yet.
+	hasWritten bool
+	w          *bufio.Writer
+}
+
+// NewEncoder returns a TOML encoder that encodes Go values to the io.Writer
+// given. By default, a single indentation level is 2 spaces.
+func NewEncoder(w io.Writer) *Encoder {
+	return &Encoder{
+		w:      bufio.NewWriter(w),
+		Indent: "  ",
+	}
+}
+
+// Encode writes a TOML representation of the Go value to the underlying
+// io.Writer. If the value given cannot be encoded to a valid TOML document,
+// then an error is returned.
+//
+// The mapping between Go values and TOML values should be precisely the same
+// as for the Decode* functions. Similarly, the TextMarshaler interface is
+// supported by encoding the resulting bytes as strings. (If you want to write
+// arbitrary binary data then you will need to use something like base64 since
+// TOML does not have any binary types.)
+//
+// When encoding TOML hashes (i.e., Go maps or structs), keys without any
+// sub-hashes are encoded first.
+//
+// If a Go map is encoded, then its keys are sorted alphabetically for
+// deterministic output. More control over this behavior may be provided if
+// there is demand for it.
+//
+// Encoding Go values without a corresponding TOML representation---like map
+// types with non-string keys---will cause an error to be returned. Similarly
+// for mixed arrays/slices, arrays/slices with nil elements, embedded
+// non-struct types and nested slices containing maps or structs.
+// (e.g., [][]map[string]string is not allowed but []map[string]string is OK
+// and so is []map[string][]string.)
+func (enc *Encoder) Encode(v interface{}) error {
+	rv := eindirect(reflect.ValueOf(v))
+	if err := enc.safeEncode(Key([]string{}), rv); err != nil {
+		return err
+	}
+	return enc.w.Flush()
+}
+
+func (enc *Encoder) safeEncode(key Key, rv reflect.Value) (err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			if terr, ok := r.(tomlEncodeError); ok {
+				err = terr.error
+				return
+			}
+			panic(r)
+		}
+	}()
+	enc.encode(key, rv)
+	return nil
+}
+
+func (enc *Encoder) encode(key Key, rv reflect.Value) {
+	// Special case. Time needs to be in ISO8601 format.
+	// Special case. If we can marshal the type to text, then we used that.
+	// Basically, this prevents the encoder for handling these types as
+	// generic structs (or whatever the underlying type of a TextMarshaler is).
+	switch rv.Interface().(type) {
+	case time.Time, TextMarshaler:
+		enc.keyEqElement(key, rv)
+		return
+	}
+
+	k := rv.Kind()
+	switch k {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
+		reflect.Uint64,
+		reflect.Float32, reflect.Float64, reflect.String, reflect.Bool:
+		enc.keyEqElement(key, rv)
+	case reflect.Array, reflect.Slice:
+		if typeEqual(tomlArrayHash, tomlTypeOfGo(rv)) {
+			enc.eArrayOfTables(key, rv)
+		} else {
+			enc.keyEqElement(key, rv)
+		}
+	case reflect.Interface:
+		if rv.IsNil() {
+			return
+		}
+		enc.encode(key, rv.Elem())
+	case reflect.Map:
+		if rv.IsNil() {
+			return
+		}
+		enc.eTable(key, rv)
+	case reflect.Ptr:
+		if rv.IsNil() {
+			return
+		}
+		enc.encode(key, rv.Elem())
+	case reflect.Struct:
+		enc.eTable(key, rv)
+	default:
+		panic(e("unsupported type for key '%s': %s", key, k))
+	}
+}
+
+// eElement encodes any value that can be an array element (primitives and
+// arrays).
+func (enc *Encoder) eElement(rv reflect.Value) {
+	switch v := rv.Interface().(type) {
+	case time.Time:
+		// Special case time.Time as a primitive. Has to come before
+		// TextMarshaler below because time.Time implements
+		// encoding.TextMarshaler, but we need to always use UTC.
+		enc.wf(v.UTC().Format("2006-01-02T15:04:05Z"))
+		return
+	case TextMarshaler:
+		// Special case. Use text marshaler if it's available for this value.
+		if s, err := v.MarshalText(); err != nil {
+			encPanic(err)
+		} else {
+			enc.writeQuoted(string(s))
+		}
+		return
+	}
+	switch rv.Kind() {
+	case reflect.Bool:
+		enc.wf(strconv.FormatBool(rv.Bool()))
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64:
+		enc.wf(strconv.FormatInt(rv.Int(), 10))
+	case reflect.Uint, reflect.Uint8, reflect.Uint16,
+		reflect.Uint32, reflect.Uint64:
+		enc.wf(strconv.FormatUint(rv.Uint(), 10))
+	case reflect.Float32:
+		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 32)))
+	case reflect.Float64:
+		enc.wf(floatAddDecimal(strconv.FormatFloat(rv.Float(), 'f', -1, 64)))
+	case reflect.Array, reflect.Slice:
+		enc.eArrayOrSliceElement(rv)
+	case reflect.Interface:
+		enc.eElement(rv.Elem())
+	case reflect.String:
+		enc.writeQuoted(rv.String())
+	default:
+		panic(e("unexpected primitive type: %s", rv.Kind()))
+	}
+}
+
+// By the TOML spec, all floats must have a decimal with at least one
+// number on either side.
+func floatAddDecimal(fstr string) string {
+	if !strings.Contains(fstr, ".") {
+		return fstr + ".0"
+	}
+	return fstr
+}
+
+func (enc *Encoder) writeQuoted(s string) {
+	enc.wf("\"%s\"", quotedReplacer.Replace(s))
+}
+
+func (enc *Encoder) eArrayOrSliceElement(rv reflect.Value) {
+	length := rv.Len()
+	enc.wf("[")
+	for i := 0; i < length; i++ {
+		elem := rv.Index(i)
+		enc.eElement(elem)
+		if i != length-1 {
+			enc.wf(", ")
+		}
+	}
+	enc.wf("]")
+}
+
+func (enc *Encoder) eArrayOfTables(key Key, rv reflect.Value) {
+	if len(key) == 0 {
+		encPanic(errNoKey)
+	}
+	for i := 0; i < rv.Len(); i++ {
+		trv := rv.Index(i)
+		if isNil(trv) {
+			continue
+		}
+		panicIfInvalidKey(key)
+		enc.newline()
+		enc.wf("%s[[%s]]", enc.indentStr(key), key.maybeQuotedAll())
+		enc.newline()
+		enc.eMapOrStruct(key, trv)
+	}
+}
+
+func (enc *Encoder) eTable(key Key, rv reflect.Value) {
+	panicIfInvalidKey(key)
+	if len(key) == 1 {
+		// Output an extra newline between top-level tables.
+		// (The newline isn't written if nothing else has been written though.)
+		enc.newline()
+	}
+	if len(key) > 0 {
+		enc.wf("%s[%s]", enc.indentStr(key), key.maybeQuotedAll())
+		enc.newline()
+	}
+	enc.eMapOrStruct(key, rv)
+}
+
+func (enc *Encoder) eMapOrStruct(key Key, rv reflect.Value) {
+	switch rv := eindirect(rv); rv.Kind() {
+	case reflect.Map:
+		enc.eMap(key, rv)
+	case reflect.Struct:
+		enc.eStruct(key, rv)
+	default:
+		panic("eTable: unhandled reflect.Value Kind: " + rv.Kind().String())
+	}
+}
+
+func (enc *Encoder) eMap(key Key, rv reflect.Value) {
+	rt := rv.Type()
+	if rt.Key().Kind() != reflect.String {
+		encPanic(errNonString)
+	}
+
+	// Sort keys so that we have deterministic output. And write keys directly
+	// underneath this key first, before writing sub-structs or sub-maps.
+	var mapKeysDirect, mapKeysSub []string
+	for _, mapKey := range rv.MapKeys() {
+		k := mapKey.String()
+		if typeIsHash(tomlTypeOfGo(rv.MapIndex(mapKey))) {
+			mapKeysSub = append(mapKeysSub, k)
+		} else {
+			mapKeysDirect = append(mapKeysDirect, k)
+		}
+	}
+
+	var writeMapKeys = func(mapKeys []string) {
+		sort.Strings(mapKeys)
+		for _, mapKey := range mapKeys {
+			mrv := rv.MapIndex(reflect.ValueOf(mapKey))
+			if isNil(mrv) {
+				// Don't write anything for nil fields.
+				continue
+			}
+			enc.encode(key.add(mapKey), mrv)
+		}
+	}
+	writeMapKeys(mapKeysDirect)
+	writeMapKeys(mapKeysSub)
+}
+
+func (enc *Encoder) eStruct(key Key, rv reflect.Value) {
+	// Write keys for fields directly under this key first, because if we write
+	// a field that creates a new table, then all keys under it will be in that
+	// table (not the one we're writing here).
+	rt := rv.Type()
+	var fieldsDirect, fieldsSub [][]int
+	var addFields func(rt reflect.Type, rv reflect.Value, start []int)
+	addFields = func(rt reflect.Type, rv reflect.Value, start []int) {
+		for i := 0; i < rt.NumField(); i++ {
+			f := rt.Field(i)
+			// skip unexported fields
+			if f.PkgPath != "" && !f.Anonymous {
+				continue
+			}
+			frv := rv.Field(i)
+			if f.Anonymous {
+				t := f.Type
+				switch t.Kind() {
+				case reflect.Struct:
+					// Treat anonymous struct fields with
+					// tag names as though they are not
+					// anonymous, like encoding/json does.
+					if getOptions(f.Tag).name == "" {
+						addFields(t, frv, f.Index)
+						continue
+					}
+				case reflect.Ptr:
+					if t.Elem().Kind() == reflect.Struct &&
+						getOptions(f.Tag).name == "" {
+						if !frv.IsNil() {
+							addFields(t.Elem(), frv.Elem(), f.Index)
+						}
+						continue
+					}
+					// Fall through to the normal field encoding logic below
+					// for non-struct anonymous fields.
+				}
+			}
+
+			if typeIsHash(tomlTypeOfGo(frv)) {
+				fieldsSub = append(fieldsSub, append(start, f.Index...))
+			} else {
+				fieldsDirect = append(fieldsDirect, append(start, f.Index...))
+			}
+		}
+	}
+	addFields(rt, rv, nil)
+
+	var writeFields = func(fields [][]int) {
+		for _, fieldIndex := range fields {
+			sft := rt.FieldByIndex(fieldIndex)
+			sf := rv.FieldByIndex(fieldIndex)
+			if isNil(sf) {
+				// Don't write anything for nil fields.
+				continue
+			}
+
+			opts := getOptions(sft.Tag)
+			if opts.skip {
+				continue
+			}
+			keyName := sft.Name
+			if opts.name != "" {
+				keyName = opts.name
+			}
+			if opts.omitempty && isEmpty(sf) {
+				continue
+			}
+			if opts.omitzero && isZero(sf) {
+				continue
+			}
+
+			enc.encode(key.add(keyName), sf)
+		}
+	}
+	writeFields(fieldsDirect)
+	writeFields(fieldsSub)
+}
+
+// tomlTypeName returns the TOML type name of the Go value's type. It is
+// used to determine whether the types of array elements are mixed (which is
+// forbidden). If the Go value is nil, then it is illegal for it to be an array
+// element, and valueIsNil is returned as true.
+
+// Returns the TOML type of a Go value. The type may be `nil`, which means
+// no concrete TOML type could be found.
+func tomlTypeOfGo(rv reflect.Value) tomlType {
+	if isNil(rv) || !rv.IsValid() {
+		return nil
+	}
+	switch rv.Kind() {
+	case reflect.Bool:
+		return tomlBool
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
+		reflect.Uint64:
+		return tomlInteger
+	case reflect.Float32, reflect.Float64:
+		return tomlFloat
+	case reflect.Array, reflect.Slice:
+		if typeEqual(tomlHash, tomlArrayType(rv)) {
+			return tomlArrayHash
+		}
+		return tomlArray
+	case reflect.Ptr, reflect.Interface:
+		return tomlTypeOfGo(rv.Elem())
+	case reflect.String:
+		return tomlString
+	case reflect.Map:
+		return tomlHash
+	case reflect.Struct:
+		switch rv.Interface().(type) {
+		case time.Time:
+			return tomlDatetime
+		case TextMarshaler:
+			return tomlString
+		default:
+			return tomlHash
+		}
+	default:
+		panic("unexpected reflect.Kind: " + rv.Kind().String())
+	}
+}
+
+// tomlArrayType returns the element type of a TOML array. The type returned
+// may be nil if it cannot be determined (e.g., a nil slice or a zero length
+// slize). This function may also panic if it finds a type that cannot be
+// expressed in TOML (such as nil elements, heterogeneous arrays or directly
+// nested arrays of tables).
+func tomlArrayType(rv reflect.Value) tomlType {
+	if isNil(rv) || !rv.IsValid() || rv.Len() == 0 {
+		return nil
+	}
+	firstType := tomlTypeOfGo(rv.Index(0))
+	if firstType == nil {
+		encPanic(errArrayNilElement)
+	}
+
+	rvlen := rv.Len()
+	for i := 1; i < rvlen; i++ {
+		elem := rv.Index(i)
+		switch elemType := tomlTypeOfGo(elem); {
+		case elemType == nil:
+			encPanic(errArrayNilElement)
+		case !typeEqual(firstType, elemType):
+			encPanic(errArrayMixedElementTypes)
+		}
+	}
+	// If we have a nested array, then we must make sure that the nested
+	// array contains ONLY primitives.
+	// This checks arbitrarily nested arrays.
+	if typeEqual(firstType, tomlArray) || typeEqual(firstType, tomlArrayHash) {
+		nest := tomlArrayType(eindirect(rv.Index(0)))
+		if typeEqual(nest, tomlHash) || typeEqual(nest, tomlArrayHash) {
+			encPanic(errArrayNoTable)
+		}
+	}
+	return firstType
+}
+
+type tagOptions struct {
+	skip      bool // "-"
+	name      string
+	omitempty bool
+	omitzero  bool
+}
+
+func getOptions(tag reflect.StructTag) tagOptions {
+	t := tag.Get("toml")
+	if t == "-" {
+		return tagOptions{skip: true}
+	}
+	var opts tagOptions
+	parts := strings.Split(t, ",")
+	opts.name = parts[0]
+	for _, s := range parts[1:] {
+		switch s {
+		case "omitempty":
+			opts.omitempty = true
+		case "omitzero":
+			opts.omitzero = true
+		}
+	}
+	return opts
+}
+
+func isZero(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return rv.Int() == 0
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return rv.Uint() == 0
+	case reflect.Float32, reflect.Float64:
+		return rv.Float() == 0.0
+	}
+	return false
+}
+
+func isEmpty(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Array, reflect.Slice, reflect.Map, reflect.String:
+		return rv.Len() == 0
+	case reflect.Bool:
+		return !rv.Bool()
+	}
+	return false
+}
+
+func (enc *Encoder) newline() {
+	if enc.hasWritten {
+		enc.wf("\n")
+	}
+}
+
+func (enc *Encoder) keyEqElement(key Key, val reflect.Value) {
+	if len(key) == 0 {
+		encPanic(errNoKey)
+	}
+	panicIfInvalidKey(key)
+	enc.wf("%s%s = ", enc.indentStr(key), key.maybeQuoted(len(key)-1))
+	enc.eElement(val)
+	enc.newline()
+}
+
+func (enc *Encoder) wf(format string, v ...interface{}) {
+	if _, err := fmt.Fprintf(enc.w, format, v...); err != nil {
+		encPanic(err)
+	}
+	enc.hasWritten = true
+}
+
+func (enc *Encoder) indentStr(key Key) string {
+	return strings.Repeat(enc.Indent, len(key)-1)
+}
+
+func encPanic(err error) {
+	panic(tomlEncodeError{err})
+}
+
+func eindirect(v reflect.Value) reflect.Value {
+	switch v.Kind() {
+	case reflect.Ptr, reflect.Interface:
+		return eindirect(v.Elem())
+	default:
+		return v
+	}
+}
+
+func isNil(rv reflect.Value) bool {
+	switch rv.Kind() {
+	case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
+		return rv.IsNil()
+	default:
+		return false
+	}
+}
+
+func panicIfInvalidKey(key Key) {
+	for _, k := range key {
+		if len(k) == 0 {
+			encPanic(e("Key '%s' is not a valid table name. Key names "+
+				"cannot be empty.", key.maybeQuotedAll()))
+		}
+	}
+}
+
+func isValidKeyName(s string) bool {
+	return len(s) != 0
+}

vendor/github.com/BurntSushi/toml/encoding_types.go

@@ -0,0 +1,19 @@
+// +build go1.2
+
+package toml
+
+// In order to support Go 1.1, we define our own TextMarshaler and
+// TextUnmarshaler types. For Go 1.2+, we just alias them with the
+// standard library interfaces.
+
+import (
+	"encoding"
+)
+
+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
+// so that Go 1.1 can be supported.
+type TextMarshaler encoding.TextMarshaler
+
+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
+// here so that Go 1.1 can be supported.
+type TextUnmarshaler encoding.TextUnmarshaler

vendor/github.com/BurntSushi/toml/encoding_types_1.1.go

@@ -0,0 +1,18 @@
+// +build !go1.2
+
+package toml
+
+// These interfaces were introduced in Go 1.2, so we add them manually when
+// compiling for Go 1.1.
+
+// TextMarshaler is a synonym for encoding.TextMarshaler. It is defined here
+// so that Go 1.1 can be supported.
+type TextMarshaler interface {
+	MarshalText() (text []byte, err error)
+}
+
+// TextUnmarshaler is a synonym for encoding.TextUnmarshaler. It is defined
+// here so that Go 1.1 can be supported.
+type TextUnmarshaler interface {
+	UnmarshalText(text []byte) error
+}

vendor/github.com/BurntSushi/toml/lex.go

@@ -0,0 +1,953 @@
+package toml
+
+import (
+	"fmt"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+type itemType int
+
+const (
+	itemError itemType = iota
+	itemNIL            // used in the parser to indicate no type
+	itemEOF
+	itemText
+	itemString
+	itemRawString
+	itemMultilineString
+	itemRawMultilineString
+	itemBool
+	itemInteger
+	itemFloat
+	itemDatetime
+	itemArray // the start of an array
+	itemArrayEnd
+	itemTableStart
+	itemTableEnd
+	itemArrayTableStart
+	itemArrayTableEnd
+	itemKeyStart
+	itemCommentStart
+	itemInlineTableStart
+	itemInlineTableEnd
+)
+
+const (
+	eof              = 0
+	comma            = ','
+	tableStart       = '['
+	tableEnd         = ']'
+	arrayTableStart  = '['
+	arrayTableEnd    = ']'
+	tableSep         = '.'
+	keySep           = '='
+	arrayStart       = '['
+	arrayEnd         = ']'
+	commentStart     = '#'
+	stringStart      = '"'
+	stringEnd        = '"'
+	rawStringStart   = '\''
+	rawStringEnd     = '\''
+	inlineTableStart = '{'
+	inlineTableEnd   = '}'
+)
+
+type stateFn func(lx *lexer) stateFn
+
+type lexer struct {
+	input string
+	start int
+	pos   int
+	line  int
+	state stateFn
+	items chan item
+
+	// Allow for backing up up to three runes.
+	// This is necessary because TOML contains 3-rune tokens (""" and ''').
+	prevWidths [3]int
+	nprev      int // how many of prevWidths are in use
+	// If we emit an eof, we can still back up, but it is not OK to call
+	// next again.
+	atEOF bool
+
+	// A stack of state functions used to maintain context.
+	// The idea is to reuse parts of the state machine in various places.
+	// For example, values can appear at the top level or within arbitrarily
+	// nested arrays. The last state on the stack is used after a value has
+	// been lexed. Similarly for comments.
+	stack []stateFn
+}
+
+type item struct {
+	typ  itemType
+	val  string
+	line int
+}
+
+func (lx *lexer) nextItem() item {
+	for {
+		select {
+		case item := <-lx.items:
+			return item
+		default:
+			lx.state = lx.state(lx)
+		}
+	}
+}
+
+func lex(input string) *lexer {
+	lx := &lexer{
+		input: input,
+		state: lexTop,
+		line:  1,
+		items: make(chan item, 10),
+		stack: make([]stateFn, 0, 10),
+	}
+	return lx
+}
+
+func (lx *lexer) push(state stateFn) {
+	lx.stack = append(lx.stack, state)
+}
+
+func (lx *lexer) pop() stateFn {
+	if len(lx.stack) == 0 {
+		return lx.errorf("BUG in lexer: no states to pop")
+	}
+	last := lx.stack[len(lx.stack)-1]
+	lx.stack = lx.stack[0 : len(lx.stack)-1]
+	return last
+}
+
+func (lx *lexer) current() string {
+	return lx.input[lx.start:lx.pos]
+}
+
+func (lx *lexer) emit(typ itemType) {
+	lx.items <- item{typ, lx.current(), lx.line}
+	lx.start = lx.pos
+}
+
+func (lx *lexer) emitTrim(typ itemType) {
+	lx.items <- item{typ, strings.TrimSpace(lx.current()), lx.line}
+	lx.start = lx.pos
+}
+
+func (lx *lexer) next() (r rune) {
+	if lx.atEOF {
+		panic("next called after EOF")
+	}
+	if lx.pos >= len(lx.input) {
+		lx.atEOF = true
+		return eof
+	}
+
+	if lx.input[lx.pos] == '\n' {
+		lx.line++
+	}
+	lx.prevWidths[2] = lx.prevWidths[1]
+	lx.prevWidths[1] = lx.prevWidths[0]
+	if lx.nprev < 3 {
+		lx.nprev++
+	}
+	r, w := utf8.DecodeRuneInString(lx.input[lx.pos:])
+	lx.prevWidths[0] = w
+	lx.pos += w
+	return r
+}
+
+// ignore skips over the pending input before this point.
+func (lx *lexer) ignore() {
+	lx.start = lx.pos
+}
+
+// backup steps back one rune. Can be called only twice between calls to next.
+func (lx *lexer) backup() {
+	if lx.atEOF {
+		lx.atEOF = false
+		return
+	}
+	if lx.nprev < 1 {
+		panic("backed up too far")
+	}
+	w := lx.prevWidths[0]
+	lx.prevWidths[0] = lx.prevWidths[1]
+	lx.prevWidths[1] = lx.prevWidths[2]
+	lx.nprev--
+	lx.pos -= w
+	if lx.pos < len(lx.input) && lx.input[lx.pos] == '\n' {
+		lx.line--
+	}
+}
+
+// accept consumes the next rune if it's equal to `valid`.
+func (lx *lexer) accept(valid rune) bool {
+	if lx.next() == valid {
+		return true
+	}
+	lx.backup()
+	return false
+}
+
+// peek returns but does not consume the next rune in the input.
+func (lx *lexer) peek() rune {
+	r := lx.next()
+	lx.backup()
+	return r
+}
+
+// skip ignores all input that matches the given predicate.
+func (lx *lexer) skip(pred func(rune) bool) {
+	for {
+		r := lx.next()
+		if pred(r) {
+			continue
+		}
+		lx.backup()
+		lx.ignore()
+		return
+	}
+}
+
+// errorf stops all lexing by emitting an error and returning `nil`.
+// Note that any value that is a character is escaped if it's a special
+// character (newlines, tabs, etc.).
+func (lx *lexer) errorf(format string, values ...interface{}) stateFn {
+	lx.items <- item{
+		itemError,
+		fmt.Sprintf(format, values...),
+		lx.line,
+	}
+	return nil
+}
+
+// lexTop consumes elements at the top level of TOML data.
+func lexTop(lx *lexer) stateFn {
+	r := lx.next()
+	if isWhitespace(r) || isNL(r) {
+		return lexSkip(lx, lexTop)
+	}
+	switch r {
+	case commentStart:
+		lx.push(lexTop)
+		return lexCommentStart
+	case tableStart:
+		return lexTableStart
+	case eof:
+		if lx.pos > lx.start {
+			return lx.errorf("unexpected EOF")
+		}
+		lx.emit(itemEOF)
+		return nil
+	}
+
+	// At this point, the only valid item can be a key, so we back up
+	// and let the key lexer do the rest.
+	lx.backup()
+	lx.push(lexTopEnd)
+	return lexKeyStart
+}
+
+// lexTopEnd is entered whenever a top-level item has been consumed. (A value
+// or a table.) It must see only whitespace, and will turn back to lexTop
+// upon a newline. If it sees EOF, it will quit the lexer successfully.
+func lexTopEnd(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == commentStart:
+		// a comment will read to a newline for us.
+		lx.push(lexTop)
+		return lexCommentStart
+	case isWhitespace(r):
+		return lexTopEnd
+	case isNL(r):
+		lx.ignore()
+		return lexTop
+	case r == eof:
+		lx.emit(itemEOF)
+		return nil
+	}
+	return lx.errorf("expected a top-level item to end with a newline, "+
+		"comment, or EOF, but got %q instead", r)
+}
+
+// lexTable lexes the beginning of a table. Namely, it makes sure that
+// it starts with a character other than '.' and ']'.
+// It assumes that '[' has already been consumed.
+// It also handles the case that this is an item in an array of tables.
+// e.g., '[[name]]'.
+func lexTableStart(lx *lexer) stateFn {
+	if lx.peek() == arrayTableStart {
+		lx.next()
+		lx.emit(itemArrayTableStart)
+		lx.push(lexArrayTableEnd)
+	} else {
+		lx.emit(itemTableStart)
+		lx.push(lexTableEnd)
+	}
+	return lexTableNameStart
+}
+
+func lexTableEnd(lx *lexer) stateFn {
+	lx.emit(itemTableEnd)
+	return lexTopEnd
+}
+
+func lexArrayTableEnd(lx *lexer) stateFn {
+	if r := lx.next(); r != arrayTableEnd {
+		return lx.errorf("expected end of table array name delimiter %q, "+
+			"but got %q instead", arrayTableEnd, r)
+	}
+	lx.emit(itemArrayTableEnd)
+	return lexTopEnd
+}
+
+func lexTableNameStart(lx *lexer) stateFn {
+	lx.skip(isWhitespace)
+	switch r := lx.peek(); {
+	case r == tableEnd || r == eof:
+		return lx.errorf("unexpected end of table name " +
+			"(table names cannot be empty)")
+	case r == tableSep:
+		return lx.errorf("unexpected table separator " +
+			"(table names cannot be empty)")
+	case r == stringStart || r == rawStringStart:
+		lx.ignore()
+		lx.push(lexTableNameEnd)
+		return lexValue // reuse string lexing
+	default:
+		return lexBareTableName
+	}
+}
+
+// lexBareTableName lexes the name of a table. It assumes that at least one
+// valid character for the table has already been read.
+func lexBareTableName(lx *lexer) stateFn {
+	r := lx.next()
+	if isBareKeyChar(r) {
+		return lexBareTableName
+	}
+	lx.backup()
+	lx.emit(itemText)
+	return lexTableNameEnd
+}
+
+// lexTableNameEnd reads the end of a piece of a table name, optionally
+// consuming whitespace.
+func lexTableNameEnd(lx *lexer) stateFn {
+	lx.skip(isWhitespace)
+	switch r := lx.next(); {
+	case isWhitespace(r):
+		return lexTableNameEnd
+	case r == tableSep:
+		lx.ignore()
+		return lexTableNameStart
+	case r == tableEnd:
+		return lx.pop()
+	default:
+		return lx.errorf("expected '.' or ']' to end table name, "+
+			"but got %q instead", r)
+	}
+}
+
+// lexKeyStart consumes a key name up until the first non-whitespace character.
+// lexKeyStart will ignore whitespace.
+func lexKeyStart(lx *lexer) stateFn {
+	r := lx.peek()
+	switch {
+	case r == keySep:
+		return lx.errorf("unexpected key separator %q", keySep)
+	case isWhitespace(r) || isNL(r):
+		lx.next()
+		return lexSkip(lx, lexKeyStart)
+	case r == stringStart || r == rawStringStart:
+		lx.ignore()
+		lx.emit(itemKeyStart)
+		lx.push(lexKeyEnd)
+		return lexValue // reuse string lexing
+	default:
+		lx.ignore()
+		lx.emit(itemKeyStart)
+		return lexBareKey
+	}
+}
+
+// lexBareKey consumes the text of a bare key. Assumes that the first character
+// (which is not whitespace) has not yet been consumed.
+func lexBareKey(lx *lexer) stateFn {
+	switch r := lx.next(); {
+	case isBareKeyChar(r):
+		return lexBareKey
+	case isWhitespace(r):
+		lx.backup()
+		lx.emit(itemText)
+		return lexKeyEnd
+	case r == keySep:
+		lx.backup()
+		lx.emit(itemText)
+		return lexKeyEnd
+	default:
+		return lx.errorf("bare keys cannot contain %q", r)
+	}
+}
+
+// lexKeyEnd consumes the end of a key and trims whitespace (up to the key
+// separator).
+func lexKeyEnd(lx *lexer) stateFn {
+	switch r := lx.next(); {
+	case r == keySep:
+		return lexSkip(lx, lexValue)
+	case isWhitespace(r):
+		return lexSkip(lx, lexKeyEnd)
+	default:
+		return lx.errorf("expected key separator %q, but got %q instead",
+			keySep, r)
+	}
+}
+
+// lexValue starts the consumption of a value anywhere a value is expected.
+// lexValue will ignore whitespace.
+// After a value is lexed, the last state on the next is popped and returned.
+func lexValue(lx *lexer) stateFn {
+	// We allow whitespace to precede a value, but NOT newlines.
+	// In array syntax, the array states are responsible for ignoring newlines.
+	r := lx.next()
+	switch {
+	case isWhitespace(r):
+		return lexSkip(lx, lexValue)
+	case isDigit(r):
+		lx.backup() // avoid an extra state and use the same as above
+		return lexNumberOrDateStart
+	}
+	switch r {
+	case arrayStart:
+		lx.ignore()
+		lx.emit(itemArray)
+		return lexArrayValue
+	case inlineTableStart:
+		lx.ignore()
+		lx.emit(itemInlineTableStart)
+		return lexInlineTableValue
+	case stringStart:
+		if lx.accept(stringStart) {
+			if lx.accept(stringStart) {
+				lx.ignore() // Ignore """
+				return lexMultilineString
+			}
+			lx.backup()
+		}
+		lx.ignore() // ignore the '"'
+		return lexString
+	case rawStringStart:
+		if lx.accept(rawStringStart) {
+			if lx.accept(rawStringStart) {
+				lx.ignore() // Ignore """
+				return lexMultilineRawString
+			}
+			lx.backup()
+		}
+		lx.ignore() // ignore the "'"
+		return lexRawString
+	case '+', '-':
+		return lexNumberStart
+	case '.': // special error case, be kind to users
+		return lx.errorf("floats must start with a digit, not '.'")
+	}
+	if unicode.IsLetter(r) {
+		// Be permissive here; lexBool will give a nice error if the
+		// user wrote something like
+		//   x = foo
+		// (i.e. not 'true' or 'false' but is something else word-like.)
+		lx.backup()
+		return lexBool
+	}
+	return lx.errorf("expected value but found %q instead", r)
+}
+
+// lexArrayValue consumes one value in an array. It assumes that '[' or ','
+// have already been consumed. All whitespace and newlines are ignored.
+func lexArrayValue(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r) || isNL(r):
+		return lexSkip(lx, lexArrayValue)
+	case r == commentStart:
+		lx.push(lexArrayValue)
+		return lexCommentStart
+	case r == comma:
+		return lx.errorf("unexpected comma")
+	case r == arrayEnd:
+		// NOTE(caleb): The spec isn't clear about whether you can have
+		// a trailing comma or not, so we'll allow it.
+		return lexArrayEnd
+	}
+
+	lx.backup()
+	lx.push(lexArrayValueEnd)
+	return lexValue
+}
+
+// lexArrayValueEnd consumes everything between the end of an array value and
+// the next value (or the end of the array): it ignores whitespace and newlines
+// and expects either a ',' or a ']'.
+func lexArrayValueEnd(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r) || isNL(r):
+		return lexSkip(lx, lexArrayValueEnd)
+	case r == commentStart:
+		lx.push(lexArrayValueEnd)
+		return lexCommentStart
+	case r == comma:
+		lx.ignore()
+		return lexArrayValue // move on to the next value
+	case r == arrayEnd:
+		return lexArrayEnd
+	}
+	return lx.errorf(
+		"expected a comma or array terminator %q, but got %q instead",
+		arrayEnd, r,
+	)
+}
+
+// lexArrayEnd finishes the lexing of an array.
+// It assumes that a ']' has just been consumed.
+func lexArrayEnd(lx *lexer) stateFn {
+	lx.ignore()
+	lx.emit(itemArrayEnd)
+	return lx.pop()
+}
+
+// lexInlineTableValue consumes one key/value pair in an inline table.
+// It assumes that '{' or ',' have already been consumed. Whitespace is ignored.
+func lexInlineTableValue(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r):
+		return lexSkip(lx, lexInlineTableValue)
+	case isNL(r):
+		return lx.errorf("newlines not allowed within inline tables")
+	case r == commentStart:
+		lx.push(lexInlineTableValue)
+		return lexCommentStart
+	case r == comma:
+		return lx.errorf("unexpected comma")
+	case r == inlineTableEnd:
+		return lexInlineTableEnd
+	}
+	lx.backup()
+	lx.push(lexInlineTableValueEnd)
+	return lexKeyStart
+}
+
+// lexInlineTableValueEnd consumes everything between the end of an inline table
+// key/value pair and the next pair (or the end of the table):
+// it ignores whitespace and expects either a ',' or a '}'.
+func lexInlineTableValueEnd(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case isWhitespace(r):
+		return lexSkip(lx, lexInlineTableValueEnd)
+	case isNL(r):
+		return lx.errorf("newlines not allowed within inline tables")
+	case r == commentStart:
+		lx.push(lexInlineTableValueEnd)
+		return lexCommentStart
+	case r == comma:
+		lx.ignore()
+		return lexInlineTableValue
+	case r == inlineTableEnd:
+		return lexInlineTableEnd
+	}
+	return lx.errorf("expected a comma or an inline table terminator %q, "+
+		"but got %q instead", inlineTableEnd, r)
+}
+
+// lexInlineTableEnd finishes the lexing of an inline table.
+// It assumes that a '}' has just been consumed.
+func lexInlineTableEnd(lx *lexer) stateFn {
+	lx.ignore()
+	lx.emit(itemInlineTableEnd)
+	return lx.pop()
+}
+
+// lexString consumes the inner contents of a string. It assumes that the
+// beginning '"' has already been consumed and ignored.
+func lexString(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == eof:
+		return lx.errorf("unexpected EOF")
+	case isNL(r):
+		return lx.errorf("strings cannot contain newlines")
+	case r == '\\':
+		lx.push(lexString)
+		return lexStringEscape
+	case r == stringEnd:
+		lx.backup()
+		lx.emit(itemString)
+		lx.next()
+		lx.ignore()
+		return lx.pop()
+	}
+	return lexString
+}
+
+// lexMultilineString consumes the inner contents of a string. It assumes that
+// the beginning '"""' has already been consumed and ignored.
+func lexMultilineString(lx *lexer) stateFn {
+	switch lx.next() {
+	case eof:
+		return lx.errorf("unexpected EOF")
+	case '\\':
+		return lexMultilineStringEscape
+	case stringEnd:
+		if lx.accept(stringEnd) {
+			if lx.accept(stringEnd) {
+				lx.backup()
+				lx.backup()
+				lx.backup()
+				lx.emit(itemMultilineString)
+				lx.next()
+				lx.next()
+				lx.next()
+				lx.ignore()
+				return lx.pop()
+			}
+			lx.backup()
+		}
+	}
+	return lexMultilineString
+}
+
+// lexRawString consumes a raw string. Nothing can be escaped in such a string.
+// It assumes that the beginning "'" has already been consumed and ignored.
+func lexRawString(lx *lexer) stateFn {
+	r := lx.next()
+	switch {
+	case r == eof:
+		return lx.errorf("unexpected EOF")
+	case isNL(r):
+		return lx.errorf("strings cannot contain newlines")
+	case r == rawStringEnd:
+		lx.backup()
+		lx.emit(itemRawString)
+		lx.next()
+		lx.ignore()
+		return lx.pop()
+	}
+	return lexRawString
+}
+
+// lexMultilineRawString consumes a raw string. Nothing can be escaped in such
+// a string. It assumes that the beginning "'''" has already been consumed and
+// ignored.
+func lexMultilineRawString(lx *lexer) stateFn {
+	switch lx.next() {
+	case eof:
+		return lx.errorf("unexpected EOF")
+	case rawStringEnd:
+		if lx.accept(rawStringEnd) {
+			if lx.accept(rawStringEnd) {
+				lx.backup()
+				lx.backup()
+				lx.backup()
+				lx.emit(itemRawMultilineString)
+				lx.next()
+				lx.next()
+				lx.next()
+				lx.ignore()
+				return lx.pop()
+			}
+			lx.backup()
+		}
+	}
+	return lexMultilineRawString
+}
+
+// lexMultilineStringEscape consumes an escaped character. It assumes that the
+// preceding '\\' has already been consumed.
+func lexMultilineStringEscape(lx *lexer) stateFn {
+	// Handle the special case first:
+	if isNL(lx.next()) {
+		return lexMultilineString
+	}
+	lx.backup()
+	lx.push(lexMultilineString)
+	return lexStringEscape(lx)
+}
+
+func lexStringEscape(lx *lexer) stateFn {
+	r := lx.next()
+	switch r {
+	case 'b':
+		fallthrough
+	case 't':
+		fallthrough
+	case 'n':
+		fallthrough
+	case 'f':
+		fallthrough
+	case 'r':
+		fallthrough
+	case '"':
+		fallthrough
+	case '\\':
+		return lx.pop()
+	case 'u':
+		return lexShortUnicodeEscape
+	case 'U':
+		return lexLongUnicodeEscape
+	}
+	return lx.errorf("invalid escape character %q; only the following "+
+		"escape characters are allowed: "+
+		`\b, \t, \n, \f, \r, \", \\, \uXXXX, and \UXXXXXXXX`, r)
+}
+
+func lexShortUnicodeEscape(lx *lexer) stateFn {
+	var r rune
+	for i := 0; i < 4; i++ {
+		r = lx.next()
+		if !isHexadecimal(r) {
+			return lx.errorf(`expected four hexadecimal digits after '\u', `+
+				"but got %q instead", lx.current())
+		}
+	}
+	return lx.pop()
+}
+
+func lexLongUnicodeEscape(lx *lexer) stateFn {
+	var r rune
+	for i := 0; i < 8; i++ {
+		r = lx.next()
+		if !isHexadecimal(r) {
+			return lx.errorf(`expected eight hexadecimal digits after '\U', `+
+				"but got %q instead", lx.current())
+		}
+	}
+	return lx.pop()
+}
+
+// lexNumberOrDateStart consumes either an integer, a float, or datetime.
+func lexNumberOrDateStart(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumberOrDate
+	}
+	switch r {
+	case '_':
+		return lexNumber
+	case 'e', 'E':
+		return lexFloat
+	case '.':
+		return lx.errorf("floats must start with a digit, not '.'")
+	}
+	return lx.errorf("expected a digit but got %q", r)
+}
+
+// lexNumberOrDate consumes either an integer, float or datetime.
+func lexNumberOrDate(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumberOrDate
+	}
+	switch r {
+	case '-':
+		return lexDatetime
+	case '_':
+		return lexNumber
+	case '.', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemInteger)
+	return lx.pop()
+}
+
+// lexDatetime consumes a Datetime, to a first approximation.
+// The parser validates that it matches one of the accepted formats.
+func lexDatetime(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexDatetime
+	}
+	switch r {
+	case '-', 'T', ':', '.', 'Z', '+':
+		return lexDatetime
+	}
+
+	lx.backup()
+	lx.emit(itemDatetime)
+	return lx.pop()
+}
+
+// lexNumberStart consumes either an integer or a float. It assumes that a sign
+// has already been read, but that *no* digits have been consumed.
+// lexNumberStart will move to the appropriate integer or float states.
+func lexNumberStart(lx *lexer) stateFn {
+	// We MUST see a digit. Even floats have to start with a digit.
+	r := lx.next()
+	if !isDigit(r) {
+		if r == '.' {
+			return lx.errorf("floats must start with a digit, not '.'")
+		}
+		return lx.errorf("expected a digit but got %q", r)
+	}
+	return lexNumber
+}
+
+// lexNumber consumes an integer or a float after seeing the first digit.
+func lexNumber(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexNumber
+	}
+	switch r {
+	case '_':
+		return lexNumber
+	case '.', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemInteger)
+	return lx.pop()
+}
+
+// lexFloat consumes the elements of a float. It allows any sequence of
+// float-like characters, so floats emitted by the lexer are only a first
+// approximation and must be validated by the parser.
+func lexFloat(lx *lexer) stateFn {
+	r := lx.next()
+	if isDigit(r) {
+		return lexFloat
+	}
+	switch r {
+	case '_', '.', '-', '+', 'e', 'E':
+		return lexFloat
+	}
+
+	lx.backup()
+	lx.emit(itemFloat)
+	return lx.pop()
+}
+
+// lexBool consumes a bool string: 'true' or 'false.
+func lexBool(lx *lexer) stateFn {
+	var rs []rune
+	for {
+		r := lx.next()
+		if !unicode.IsLetter(r) {
+			lx.backup()
+			break
+		}
+		rs = append(rs, r)
+	}
+	s := string(rs)
+	switch s {
+	case "true", "false":
+		lx.emit(itemBool)
+		return lx.pop()
+	}
+	return lx.errorf("expected value but found %q instead", s)
+}
+
+// lexCommentStart begins the lexing of a comment. It will emit
+// itemCommentStart and consume no characters, passing control to lexComment.
+func lexCommentStart(lx *lexer) stateFn {
+	lx.ignore()
+	lx.emit(itemCommentStart)
+	return lexComment
+}
+
+// lexComment lexes an entire comment. It assumes that '#' has been consumed.
+// It will consume *up to* the first newline character, and pass control
+// back to the last state on the stack.
+func lexComment(lx *lexer) stateFn {
+	r := lx.peek()
+	if isNL(r) || r == eof {
+		lx.emit(itemText)
+		return lx.pop()
+	}
+	lx.next()
+	return lexComment
+}
+
+// lexSkip ignores all slurped input and moves on to the next state.
+func lexSkip(lx *lexer, nextState stateFn) stateFn {
+	return func(lx *lexer) stateFn {
+		lx.ignore()
+		return nextState
+	}
+}
+
+// isWhitespace returns true if `r` is a whitespace character according
+// to the spec.
+func isWhitespace(r rune) bool {
+	return r == '\t' || r == ' '
+}
+
+func isNL(r rune) bool {
+	return r == '\n' || r == '\r'
+}
+
+func isDigit(r rune) bool {
+	return r >= '0' && r <= '9'
+}
+
+func isHexadecimal(r rune) bool {
+	return (r >= '0' && r <= '9') ||
+		(r >= 'a' && r <= 'f') ||
+		(r >= 'A' && r <= 'F')
+}
+
+func isBareKeyChar(r rune) bool {
+	return (r >= 'A' && r <= 'Z') ||
+		(r >= 'a' && r <= 'z') ||
+		(r >= '0' && r <= '9') ||
+		r == '_' ||
+		r == '-'
+}
+
+func (itype itemType) String() string {
+	switch itype {
+	case itemError:
+		return "Error"
+	case itemNIL:
+		return "NIL"
+	case itemEOF:
+		return "EOF"
+	case itemText:
+		return "Text"
+	case itemString, itemRawString, itemMultilineString, itemRawMultilineString:
+		return "String"
+	case itemBool:
+		return "Bool"
+	case itemInteger:
+		return "Integer"
+	case itemFloat:
+		return "Float"
+	case itemDatetime:
+		return "DateTime"
+	case itemTableStart:
+		return "TableStart"
+	case itemTableEnd:
+		return "TableEnd"
+	case itemKeyStart:
+		return "KeyStart"
+	case itemArray:
+		return "Array"
+	case itemArrayEnd:
+		return "ArrayEnd"
+	case itemCommentStart:
+		return "CommentStart"
+	}
+	panic(fmt.Sprintf("BUG: Unknown type '%d'.", int(itype)))
+}
+
+func (item item) String() string {
+	return fmt.Sprintf("(%s, %s)", item.typ.String(), item.val)
+}

vendor/github.com/BurntSushi/toml/parse.go

@@ -0,0 +1,592 @@
+package toml
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+type parser struct {
+	mapping map[string]interface{}
+	types   map[string]tomlType
+	lx      *lexer
+
+	// A list of keys in the order that they appear in the TOML data.
+	ordered []Key
+
+	// the full key for the current hash in scope
+	context Key
+
+	// the base key name for everything except hashes
+	currentKey string
+
+	// rough approximation of line number
+	approxLine int
+
+	// A map of 'key.group.names' to whether they were created implicitly.
+	implicits map[string]bool
+}
+
+type parseError string
+
+func (pe parseError) Error() string {
+	return string(pe)
+}
+
+func parse(data string) (p *parser, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			var ok bool
+			if err, ok = r.(parseError); ok {
+				return
+			}
+			panic(r)
+		}
+	}()
+
+	p = &parser{
+		mapping:   make(map[string]interface{}),
+		types:     make(map[string]tomlType),
+		lx:        lex(data),
+		ordered:   make([]Key, 0),
+		implicits: make(map[string]bool),
+	}
+	for {
+		item := p.next()
+		if item.typ == itemEOF {
+			break
+		}
+		p.topLevel(item)
+	}
+
+	return p, nil
+}
+
+func (p *parser) panicf(format string, v ...interface{}) {
+	msg := fmt.Sprintf("Near line %d (last key parsed '%s'): %s",
+		p.approxLine, p.current(), fmt.Sprintf(format, v...))
+	panic(parseError(msg))
+}
+
+func (p *parser) next() item {
+	it := p.lx.nextItem()
+	if it.typ == itemError {
+		p.panicf("%s", it.val)
+	}
+	return it
+}
+
+func (p *parser) bug(format string, v ...interface{}) {
+	panic(fmt.Sprintf("BUG: "+format+"\n\n", v...))
+}
+
+func (p *parser) expect(typ itemType) item {
+	it := p.next()
+	p.assertEqual(typ, it.typ)
+	return it
+}
+
+func (p *parser) assertEqual(expected, got itemType) {
+	if expected != got {
+		p.bug("Expected '%s' but got '%s'.", expected, got)
+	}
+}
+
+func (p *parser) topLevel(item item) {
+	switch item.typ {
+	case itemCommentStart:
+		p.approxLine = item.line
+		p.expect(itemText)
+	case itemTableStart:
+		kg := p.next()
+		p.approxLine = kg.line
+
+		var key Key
+		for ; kg.typ != itemTableEnd && kg.typ != itemEOF; kg = p.next() {
+			key = append(key, p.keyString(kg))
+		}
+		p.assertEqual(itemTableEnd, kg.typ)
+
+		p.establishContext(key, false)
+		p.setType("", tomlHash)
+		p.ordered = append(p.ordered, key)
+	case itemArrayTableStart:
+		kg := p.next()
+		p.approxLine = kg.line
+
+		var key Key
+		for ; kg.typ != itemArrayTableEnd && kg.typ != itemEOF; kg = p.next() {
+			key = append(key, p.keyString(kg))
+		}
+		p.assertEqual(itemArrayTableEnd, kg.typ)
+
+		p.establishContext(key, true)
+		p.setType("", tomlArrayHash)
+		p.ordered = append(p.ordered, key)
+	case itemKeyStart:
+		kname := p.next()
+		p.approxLine = kname.line
+		p.currentKey = p.keyString(kname)
+
+		val, typ := p.value(p.next())
+		p.setValue(p.currentKey, val)
+		p.setType(p.currentKey, typ)
+		p.ordered = append(p.ordered, p.context.add(p.currentKey))
+		p.currentKey = ""
+	default:
+		p.bug("Unexpected type at top level: %s", item.typ)
+	}
+}
+
+// Gets a string for a key (or part of a key in a table name).
+func (p *parser) keyString(it item) string {
+	switch it.typ {
+	case itemText:
+		return it.val
+	case itemString, itemMultilineString,
+		itemRawString, itemRawMultilineString:
+		s, _ := p.value(it)
+		return s.(string)
+	default:
+		p.bug("Unexpected key type: %s", it.typ)
+		panic("unreachable")
+	}
+}
+
+// value translates an expected value from the lexer into a Go value wrapped
+// as an empty interface.
+func (p *parser) value(it item) (interface{}, tomlType) {
+	switch it.typ {
+	case itemString:
+		return p.replaceEscapes(it.val), p.typeOfPrimitive(it)
+	case itemMultilineString:
+		trimmed := stripFirstNewline(stripEscapedWhitespace(it.val))
+		return p.replaceEscapes(trimmed), p.typeOfPrimitive(it)
+	case itemRawString:
+		return it.val, p.typeOfPrimitive(it)
+	case itemRawMultilineString:
+		return stripFirstNewline(it.val), p.typeOfPrimitive(it)
+	case itemBool:
+		switch it.val {
+		case "true":
+			return true, p.typeOfPrimitive(it)
+		case "false":
+			return false, p.typeOfPrimitive(it)
+		}
+		p.bug("Expected boolean value, but got '%s'.", it.val)
+	case itemInteger:
+		if !numUnderscoresOK(it.val) {
+			p.panicf("Invalid integer %q: underscores must be surrounded by digits",
+				it.val)
+		}
+		val := strings.Replace(it.val, "_", "", -1)
+		num, err := strconv.ParseInt(val, 10, 64)
+		if err != nil {
+			// Distinguish integer values. Normally, it'd be a bug if the lexer
+			// provides an invalid integer, but it's possible that the number is
+			// out of range of valid values (which the lexer cannot determine).
+			// So mark the former as a bug but the latter as a legitimate user
+			// error.
+			if e, ok := err.(*strconv.NumError); ok &&
+				e.Err == strconv.ErrRange {
+
+				p.panicf("Integer '%s' is out of the range of 64-bit "+
+					"signed integers.", it.val)
+			} else {
+				p.bug("Expected integer value, but got '%s'.", it.val)
+			}
+		}
+		return num, p.typeOfPrimitive(it)
+	case itemFloat:
+		parts := strings.FieldsFunc(it.val, func(r rune) bool {
+			switch r {
+			case '.', 'e', 'E':
+				return true
+			}
+			return false
+		})
+		for _, part := range parts {
+			if !numUnderscoresOK(part) {
+				p.panicf("Invalid float %q: underscores must be "+
+					"surrounded by digits", it.val)
+			}
+		}
+		if !numPeriodsOK(it.val) {
+			// As a special case, numbers like '123.' or '1.e2',
+			// which are valid as far as Go/strconv are concerned,
+			// must be rejected because TOML says that a fractional
+			// part consists of '.' followed by 1+ digits.
+			p.panicf("Invalid float %q: '.' must be followed "+
+				"by one or more digits", it.val)
+		}
+		val := strings.Replace(it.val, "_", "", -1)
+		num, err := strconv.ParseFloat(val, 64)
+		if err != nil {
+			if e, ok := err.(*strconv.NumError); ok &&
+				e.Err == strconv.ErrRange {
+
+				p.panicf("Float '%s' is out of the range of 64-bit "+
+					"IEEE-754 floating-point numbers.", it.val)
+			} else {
+				p.panicf("Invalid float value: %q", it.val)
+			}
+		}
+		return num, p.typeOfPrimitive(it)
+	case itemDatetime:
+		var t time.Time
+		var ok bool
+		var err error
+		for _, format := range []string{
+			"2006-01-02T15:04:05Z07:00",
+			"2006-01-02T15:04:05",
+			"2006-01-02",
+		} {
+			t, err = time.ParseInLocation(format, it.val, time.Local)
+			if err == nil {
+				ok = true
+				break
+			}
+		}
+		if !ok {
+			p.panicf("Invalid TOML Datetime: %q.", it.val)
+		}
+		return t, p.typeOfPrimitive(it)
+	case itemArray:
+		array := make([]interface{}, 0)
+		types := make([]tomlType, 0)
+
+		for it = p.next(); it.typ != itemArrayEnd; it = p.next() {
+			if it.typ == itemCommentStart {
+				p.expect(itemText)
+				continue
+			}
+
+			val, typ := p.value(it)
+			array = append(array, val)
+			types = append(types, typ)
+		}
+		return array, p.typeOfArray(types)
+	case itemInlineTableStart:
+		var (
+			hash         = make(map[string]interface{})
+			outerContext = p.context
+			outerKey     = p.currentKey
+		)
+
+		p.context = append(p.context, p.currentKey)
+		p.currentKey = ""
+		for it := p.next(); it.typ != itemInlineTableEnd; it = p.next() {
+			if it.typ != itemKeyStart {
+				p.bug("Expected key start but instead found %q, around line %d",
+					it.val, p.approxLine)
+			}
+			if it.typ == itemCommentStart {
+				p.expect(itemText)
+				continue
+			}
+
+			// retrieve key
+			k := p.next()
+			p.approxLine = k.line
+			kname := p.keyString(k)
+
+			// retrieve value
+			p.currentKey = kname
+			val, typ := p.value(p.next())
+			// make sure we keep metadata up to date
+			p.setType(kname, typ)
+			p.ordered = append(p.ordered, p.context.add(p.currentKey))
+			hash[kname] = val
+		}
+		p.context = outerContext
+		p.currentKey = outerKey
+		return hash, tomlHash
+	}
+	p.bug("Unexpected value type: %s", it.typ)
+	panic("unreachable")
+}
+
+// numUnderscoresOK checks whether each underscore in s is surrounded by
+// characters that are not underscores.
+func numUnderscoresOK(s string) bool {
+	accept := false
+	for _, r := range s {
+		if r == '_' {
+			if !accept {
+				return false
+			}
+			accept = false
+			continue
+		}
+		accept = true
+	}
+	return accept
+}
+
+// numPeriodsOK checks whether every period in s is followed by a digit.
+func numPeriodsOK(s string) bool {
+	period := false
+	for _, r := range s {
+		if period && !isDigit(r) {
+			return false
+		}
+		period = r == '.'
+	}
+	return !period
+}
+
+// establishContext sets the current context of the parser,
+// where the context is either a hash or an array of hashes. Which one is
+// set depends on the value of the `array` parameter.
+//
+// Establishing the context also makes sure that the key isn't a duplicate, and
+// will create implicit hashes automatically.
+func (p *parser) establishContext(key Key, array bool) {
+	var ok bool
+
+	// Always start at the top level and drill down for our context.
+	hashContext := p.mapping
+	keyContext := make(Key, 0)
+
+	// We only need implicit hashes for key[0:-1]
+	for _, k := range key[0 : len(key)-1] {
+		_, ok = hashContext[k]
+		keyContext = append(keyContext, k)
+
+		// No key? Make an implicit hash and move on.
+		if !ok {
+			p.addImplicit(keyContext)
+			hashContext[k] = make(map[string]interface{})
+		}
+
+		// If the hash context is actually an array of tables, then set
+		// the hash context to the last element in that array.
+		//
+		// Otherwise, it better be a table, since this MUST be a key group (by
+		// virtue of it not being the last element in a key).
+		switch t := hashContext[k].(type) {
+		case []map[string]interface{}:
+			hashContext = t[len(t)-1]
+		case map[string]interface{}:
+			hashContext = t
+		default:
+			p.panicf("Key '%s' was already created as a hash.", keyContext)
+		}
+	}
+
+	p.context = keyContext
+	if array {
+		// If this is the first element for this array, then allocate a new
+		// list of tables for it.
+		k := key[len(key)-1]
+		if _, ok := hashContext[k]; !ok {
+			hashContext[k] = make([]map[string]interface{}, 0, 5)
+		}
+
+		// Add a new table. But make sure the key hasn't already been used
+		// for something else.
+		if hash, ok := hashContext[k].([]map[string]interface{}); ok {
+			hashContext[k] = append(hash, make(map[string]interface{}))
+		} else {
+			p.panicf("Key '%s' was already created and cannot be used as "+
+				"an array.", keyContext)
+		}
+	} else {
+		p.setValue(key[len(key)-1], make(map[string]interface{}))
+	}
+	p.context = append(p.context, key[len(key)-1])
+}
+
+// setValue sets the given key to the given value in the current context.
+// It will make sure that the key hasn't already been defined, account for
+// implicit key groups.
+func (p *parser) setValue(key string, value interface{}) {
+	var tmpHash interface{}
+	var ok bool
+
+	hash := p.mapping
+	keyContext := make(Key, 0)
+	for _, k := range p.context {
+		keyContext = append(keyContext, k)
+		if tmpHash, ok = hash[k]; !ok {
+			p.bug("Context for key '%s' has not been established.", keyContext)
+		}
+		switch t := tmpHash.(type) {
+		case []map[string]interface{}:
+			// The context is a table of hashes. Pick the most recent table
+			// defined as the current hash.
+			hash = t[len(t)-1]
+		case map[string]interface{}:
+			hash = t
+		default:
+			p.bug("Expected hash to have type 'map[string]interface{}', but "+
+				"it has '%T' instead.", tmpHash)
+		}
+	}
+	keyContext = append(keyContext, key)
+
+	if _, ok := hash[key]; ok {
+		// Typically, if the given key has already been set, then we have
+		// to raise an error since duplicate keys are disallowed. However,
+		// it's possible that a key was previously defined implicitly. In this
+		// case, it is allowed to be redefined concretely. (See the
+		// `tests/valid/implicit-and-explicit-after.toml` test in `toml-test`.)
+		//
+		// But we have to make sure to stop marking it as an implicit. (So that
+		// another redefinition provokes an error.)
+		//
+		// Note that since it has already been defined (as a hash), we don't
+		// want to overwrite it. So our business is done.
+		if p.isImplicit(keyContext) {
+			p.removeImplicit(keyContext)
+			return
+		}
+
+		// Otherwise, we have a concrete key trying to override a previous
+		// key, which is *always* wrong.
+		p.panicf("Key '%s' has already been defined.", keyContext)
+	}
+	hash[key] = value
+}
+
+// setType sets the type of a particular value at a given key.
+// It should be called immediately AFTER setValue.
+//
+// Note that if `key` is empty, then the type given will be applied to the
+// current context (which is either a table or an array of tables).
+func (p *parser) setType(key string, typ tomlType) {
+	keyContext := make(Key, 0, len(p.context)+1)
+	for _, k := range p.context {
+		keyContext = append(keyContext, k)
+	}
+	if len(key) > 0 { // allow type setting for hashes
+		keyContext = append(keyContext, key)
+	}
+	p.types[keyContext.String()] = typ
+}
+
+// addImplicit sets the given Key as having been created implicitly.
+func (p *parser) addImplicit(key Key) {
+	p.implicits[key.String()] = true
+}
+
+// removeImplicit stops tagging the given key as having been implicitly
+// created.
+func (p *parser) removeImplicit(key Key) {
+	p.implicits[key.String()] = false
+}
+
+// isImplicit returns true if the key group pointed to by the key was created
+// implicitly.
+func (p *parser) isImplicit(key Key) bool {
+	return p.implicits[key.String()]
+}
+
+// current returns the full key name of the current context.
+func (p *parser) current() string {
+	if len(p.currentKey) == 0 {
+		return p.context.String()
+	}
+	if len(p.context) == 0 {
+		return p.currentKey
+	}
+	return fmt.Sprintf("%s.%s", p.context, p.currentKey)
+}
+
+func stripFirstNewline(s string) string {
+	if len(s) == 0 || s[0] != '\n' {
+		return s
+	}
+	return s[1:]
+}
+
+func stripEscapedWhitespace(s string) string {
+	esc := strings.Split(s, "\\\n")
+	if len(esc) > 1 {
+		for i := 1; i < len(esc); i++ {
+			esc[i] = strings.TrimLeftFunc(esc[i], unicode.IsSpace)
+		}
+	}
+	return strings.Join(esc, "")
+}
+
+func (p *parser) replaceEscapes(str string) string {
+	var replaced []rune
+	s := []byte(str)
+	r := 0
+	for r < len(s) {
+		if s[r] != '\\' {
+			c, size := utf8.DecodeRune(s[r:])
+			r += size
+			replaced = append(replaced, c)
+			continue
+		}
+		r += 1
+		if r >= len(s) {
+			p.bug("Escape sequence at end of string.")
+			return ""
+		}
+		switch s[r] {
+		default:
+			p.bug("Expected valid escape code after \\, but got %q.", s[r])
+			return ""
+		case 'b':
+			replaced = append(replaced, rune(0x0008))
+			r += 1
+		case 't':
+			replaced = append(replaced, rune(0x0009))
+			r += 1
+		case 'n':
+			replaced = append(replaced, rune(0x000A))
+			r += 1
+		case 'f':
+			replaced = append(replaced, rune(0x000C))
+			r += 1
+		case 'r':
+			replaced = append(replaced, rune(0x000D))
+			r += 1
+		case '"':
+			replaced = append(replaced, rune(0x0022))
+			r += 1
+		case '\\':
+			replaced = append(replaced, rune(0x005C))
+			r += 1
+		case 'u':
+			// At this point, we know we have a Unicode escape of the form
+			// `uXXXX` at [r, r+5). (Because the lexer guarantees this
+			// for us.)
+			escaped := p.asciiEscapeToUnicode(s[r+1 : r+5])
+			replaced = append(replaced, escaped)
+			r += 5
+		case 'U':
+			// At this point, we know we have a Unicode escape of the form
+			// `uXXXX` at [r, r+9). (Because the lexer guarantees this
+			// for us.)
+			escaped := p.asciiEscapeToUnicode(s[r+1 : r+9])
+			replaced = append(replaced, escaped)
+			r += 9
+		}
+	}
+	return string(replaced)
+}
+
+func (p *parser) asciiEscapeToUnicode(bs []byte) rune {
+	s := string(bs)
+	hex, err := strconv.ParseUint(strings.ToLower(s), 16, 32)
+	if err != nil {
+		p.bug("Could not parse '%s' as a hexadecimal number, but the "+
+			"lexer claims it's OK: %s", s, err)
+	}
+	if !utf8.ValidRune(rune(hex)) {
+		p.panicf("Escaped character '\\u%s' is not valid UTF-8.", s)
+	}
+	return rune(hex)
+}
+
+func isStringType(ty itemType) bool {
+	return ty == itemString || ty == itemMultilineString ||
+		ty == itemRawString || ty == itemRawMultilineString
+}

vendor/github.com/BurntSushi/toml/session.vim

@@ -0,0 +1 @@
+au BufWritePost *.go silent!make tags > /dev/null 2>&1

vendor/github.com/BurntSushi/toml/type_check.go

@@ -0,0 +1,91 @@
+package toml
+
+// tomlType represents any Go type that corresponds to a TOML type.
+// While the first draft of the TOML spec has a simplistic type system that
+// probably doesn't need this level of sophistication, we seem to be militating
+// toward adding real composite types.
+type tomlType interface {
+	typeString() string
+}
+
+// typeEqual accepts any two types and returns true if they are equal.
+func typeEqual(t1, t2 tomlType) bool {
+	if t1 == nil || t2 == nil {
+		return false
+	}
+	return t1.typeString() == t2.typeString()
+}
+
+func typeIsHash(t tomlType) bool {
+	return typeEqual(t, tomlHash) || typeEqual(t, tomlArrayHash)
+}
+
+type tomlBaseType string
+
+func (btype tomlBaseType) typeString() string {
+	return string(btype)
+}
+
+func (btype tomlBaseType) String() string {
+	return btype.typeString()
+}
+
+var (
+	tomlInteger   tomlBaseType = "Integer"
+	tomlFloat     tomlBaseType = "Float"
+	tomlDatetime  tomlBaseType = "Datetime"
+	tomlString    tomlBaseType = "String"
+	tomlBool      tomlBaseType = "Bool"
+	tomlArray     tomlBaseType = "Array"
+	tomlHash      tomlBaseType = "Hash"
+	tomlArrayHash tomlBaseType = "ArrayHash"
+)
+
+// typeOfPrimitive returns a tomlType of any primitive value in TOML.
+// Primitive values are: Integer, Float, Datetime, String and Bool.
+//
+// Passing a lexer item other than the following will cause a BUG message
+// to occur: itemString, itemBool, itemInteger, itemFloat, itemDatetime.
+func (p *parser) typeOfPrimitive(lexItem item) tomlType {
+	switch lexItem.typ {
+	case itemInteger:
+		return tomlInteger
+	case itemFloat:
+		return tomlFloat
+	case itemDatetime:
+		return tomlDatetime
+	case itemString:
+		return tomlString
+	case itemMultilineString:
+		return tomlString
+	case itemRawString:
+		return tomlString
+	case itemRawMultilineString:
+		return tomlString
+	case itemBool:
+		return tomlBool
+	}
+	p.bug("Cannot infer primitive type of lex item '%s'.", lexItem)
+	panic("unreachable")
+}
+
+// typeOfArray returns a tomlType for an array given a list of types of its
+// values.
+//
+// In the current spec, if an array is homogeneous, then its type is always
+// "Array". If the array is not homogeneous, an error is generated.
+func (p *parser) typeOfArray(types []tomlType) tomlType {
+	// Empty arrays are cool.
+	if len(types) == 0 {
+		return tomlArray
+	}
+
+	theType := types[0]
+	for _, t := range types[1:] {
+		if !typeEqual(theType, t) {
+			p.panicf("Array contains values of type '%s' and '%s', but "+
+				"arrays must be homogeneous.", theType, t)
+		}
+	}
+	return tomlArray
+}

vendor/github.com/BurntSushi/toml/type_fields.go

@@ -0,0 +1,242 @@
+package toml
+
+// Struct field handling is adapted from code in encoding/json:
+//
+// Copyright 2010 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the Go distribution.
+
+import (
+	"reflect"
+	"sort"
+	"sync"
+)
+
+// A field represents a single field found in a struct.
+type field struct {
+	name  string       // the name of the field (`toml` tag included)
+	tag   bool         // whether field has a `toml` tag
+	index []int        // represents the depth of an anonymous field
+	typ   reflect.Type // the type of the field
+}
+
+// byName sorts field by name, breaking ties with depth,
+// then breaking ties with "name came from toml tag", then
+// breaking ties with index sequence.
+type byName []field
+
+func (x byName) Len() int { return len(x) }
+
+func (x byName) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+func (x byName) Less(i, j int) bool {
+	if x[i].name != x[j].name {
+		return x[i].name < x[j].name
+	}
+	if len(x[i].index) != len(x[j].index) {
+		return len(x[i].index) < len(x[j].index)
+	}
+	if x[i].tag != x[j].tag {
+		return x[i].tag
+	}
+	return byIndex(x).Less(i, j)
+}
+
+// byIndex sorts field by index sequence.
+type byIndex []field
+
+func (x byIndex) Len() int { return len(x) }
+
+func (x byIndex) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
+
+func (x byIndex) Less(i, j int) bool {
+	for k, xik := range x[i].index {
+		if k >= len(x[j].index) {
+			return false
+		}
+		if xik != x[j].index[k] {
+			return xik < x[j].index[k]
+		}
+	}
+	return len(x[i].index) < len(x[j].index)
+}
+
+// typeFields returns a list of fields that TOML should recognize for the given
+// type. The algorithm is breadth-first search over the set of structs to
+// include - the top struct and then any reachable anonymous structs.
+func typeFields(t reflect.Type) []field {
+	// Anonymous fields to explore at the current level and the next.
+	current := []field{}
+	next := []field{{typ: t}}
+
+	// Count of queued names for current level and the next.
+	count := map[reflect.Type]int{}
+	nextCount := map[reflect.Type]int{}
+
+	// Types already visited at an earlier level.
+	visited := map[reflect.Type]bool{}
+
+	// Fields found.
+	var fields []field
+
+	for len(next) > 0 {
+		current, next = next, current[:0]
+		count, nextCount = nextCount, map[reflect.Type]int{}
+
+		for _, f := range current {
+			if visited[f.typ] {
+				continue
+			}
+			visited[f.typ] = true
+
+			// Scan f.typ for fields to include.
+			for i := 0; i < f.typ.NumField(); i++ {
+				sf := f.typ.Field(i)
+				if sf.PkgPath != "" && !sf.Anonymous { // unexported
+					continue
+				}
+				opts := getOptions(sf.Tag)
+				if opts.skip {
+					continue
+				}
+				index := make([]int, len(f.index)+1)
+				copy(index, f.index)
+				index[len(f.index)] = i
+
+				ft := sf.Type
+				if ft.Name() == "" && ft.Kind() == reflect.Ptr {
+					// Follow pointer.
+					ft = ft.Elem()
+				}
+
+				// Record found field and index sequence.
+				if opts.name != "" || !sf.Anonymous || ft.Kind() != reflect.Struct {
+					tagged := opts.name != ""
+					name := opts.name
+					if name == "" {
+						name = sf.Name
+					}
+					fields = append(fields, field{name, tagged, index, ft})
+					if count[f.typ] > 1 {
+						// If there were multiple instances, add a second,
+						// so that the annihilation code will see a duplicate.
+						// It only cares about the distinction between 1 or 2,
+						// so don't bother generating any more copies.
+						fields = append(fields, fields[len(fields)-1])
+					}
+					continue
+				}
+
+				// Record new anonymous struct to explore in next round.
+				nextCount[ft]++
+				if nextCount[ft] == 1 {
+					f := field{name: ft.Name(), index: index, typ: ft}
+					next = append(next, f)
+				}
+			}
+		}
+	}
+
+	sort.Sort(byName(fields))
+
+	// Delete all fields that are hidden by the Go rules for embedded fields,
+	// except that fields with TOML tags are promoted.
+
+	// The fields are sorted in primary order of name, secondary order
+	// of field index length. Loop over names; for each name, delete
+	// hidden fields by choosing the one dominant field that survives.
+	out := fields[:0]
+	for advance, i := 0, 0; i < len(fields); i += advance {
+		// One iteration per name.
+		// Find the sequence of fields with the name of this first field.
+		fi := fields[i]
+		name := fi.name
+		for advance = 1; i+advance < len(fields); advance++ {
+			fj := fields[i+advance]
+			if fj.name != name {
+				break
+			}
+		}
+		if advance == 1 { // Only one field with this name
+			out = append(out, fi)
+			continue
+		}
+		dominant, ok := dominantField(fields[i : i+advance])
+		if ok {
+			out = append(out, dominant)
+		}
+	}
+
+	fields = out
+	sort.Sort(byIndex(fields))
+
+	return fields
+}
+
+// dominantField looks through the fields, all of which are known to
+// have the same name, to find the single field that dominates the
+// others using Go's embedding rules, modified by the presence of
+// TOML tags. If there are multiple top-level fields, the boolean
+// will be false: This condition is an error in Go and we skip all
+// the fields.
+func dominantField(fields []field) (field, bool) {
+	// The fields are sorted in increasing index-length order. The winner
+	// must therefore be one with the shortest index length. Drop all
+	// longer entries, which is easy: just truncate the slice.
+	length := len(fields[0].index)
+	tagged := -1 // Index of first tagged field.
+	for i, f := range fields {
+		if len(f.index) > length {
+			fields = fields[:i]
+			break
+		}
+		if f.tag {
+			if tagged >= 0 {
+				// Multiple tagged fields at the same level: conflict.
+				// Return no field.
+				return field{}, false
+			}
+			tagged = i
+		}
+	}
+	if tagged >= 0 {
+		return fields[tagged], true
+	}
+	// All remaining fields have the same length. If there's more than one,
+	// we have a conflict (two fields named "X" at the same level) and we
+	// return no field.
+	if len(fields) > 1 {
+		return field{}, false
+	}
+	return fields[0], true
+}
+
+var fieldCache struct {
+	sync.RWMutex
+	m map[reflect.Type][]field
+}
+
+// cachedTypeFields is like typeFields but uses a cache to avoid repeated work.
+func cachedTypeFields(t reflect.Type) []field {
+	fieldCache.RLock()
+	f := fieldCache.m[t]
+	fieldCache.RUnlock()
+	if f != nil {
+		return f
+	}
+
+	// Compute fields without lock.
+	// Might duplicate effort but won't hold other computations back.
+	f = typeFields(t)
+	if f == nil {
+		f = []field{}
+	}
+
+	fieldCache.Lock()
+	if fieldCache.m == nil {
+		fieldCache.m = map[reflect.Type][]field{}
+	}
+	fieldCache.m[t] = f
+	fieldCache.Unlock()
+	return f
+}

vendor/github.com/Dai0522/go-hash/bloomfilter/BUILD.bazel

@@ -0,0 +1,28 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "bitmap.go",
+        "bloomfilter.go",
+        "strategies.go",
+    ],
+    importmap = "go-common/vendor/github.com/Dai0522/go-hash/bloomfilter",
+    importpath = "github.com/Dai0522/go-hash/bloomfilter",
+    visibility = ["//visibility:public"],
+    deps = ["//vendor/github.com/Dai0522/go-hash/murmur3:go_default_library"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/Dai0522/go-hash/bloomfilter/bitmap.go

@@ -0,0 +1,134 @@
+package bloomfilter
+
+import (
+	"errors"
+	"math"
+	"sync/atomic"
+)
+
+const (
+	// AddrBits .
+	AddrBits = 6
+)
+
+// Bitmap .
+type Bitmap interface {
+	Set(uint64) bool
+	Get(uint64) bool
+	BitSize() uint64
+	BitCount() uint64
+	Size() uint32
+	Data() *[]uint64
+	Merge(*[]uint64) bool
+}
+
+// LockFreeBitmap .
+type LockFreeBitmap struct {
+	data     []uint64
+	bitCount uint64
+}
+
+// NewLockFreeBitmap .
+func NewLockFreeBitmap(bits uint64) (*LockFreeBitmap, error) {
+	size := int(math.Ceil(float64(bits) / 64.0))
+	if size <= 0 {
+		err := errors.New("data length is zero")
+		return nil, err
+	}
+	bm := &LockFreeBitmap{
+		data:     make([]uint64, size),
+		bitCount: 0,
+	}
+	return bm, nil
+}
+
+// LoadLockFreeBitmap .
+func LoadLockFreeBitmap(d *[]uint64) *LockFreeBitmap {
+	count := uint64(0)
+	for _, v := range *d {
+		count += bitCount(v)
+	}
+	return &LockFreeBitmap{
+		data:     *d,
+		bitCount: count,
+	}
+}
+
+// Set .
+func (bits *LockFreeBitmap) Set(bitIndex uint64) bool {
+	if bits.Get(bitIndex) {
+		return false
+	}
+
+	longIndex := bitIndex >> AddrBits
+	mask := uint64(1 << (bitIndex & 63))
+
+	for {
+		old := bits.data[longIndex]
+		new := old | mask
+		if old == new {
+			return false
+		}
+		if atomic.CompareAndSwapUint64(&bits.data[longIndex], old, new) {
+			break
+		}
+	}
+
+	atomic.AddUint64(&bits.bitCount, 1)
+	return true
+}
+
+// Get .
+func (bits *LockFreeBitmap) Get(bitIndex uint64) bool {
+	return bits.data[bitIndex>>AddrBits]&(uint64(1<<(bitIndex&63))) != 0
+}
+
+// BitSize .
+func (bits *LockFreeBitmap) BitSize() uint64 {
+	return uint64(len(bits.data) * 64)
+}
+
+// BitCount .
+func (bits *LockFreeBitmap) BitCount() uint64 {
+	return bits.bitCount
+}
+
+// Size .
+func (bits *LockFreeBitmap) Size() uint32 {
+	return uint32(len(bits.data))
+}
+
+// Data .
+func (bits *LockFreeBitmap) Data() *[]uint64 {
+	return &bits.data
+}
+
+// Merge .
+func (bits *LockFreeBitmap) Merge(data *[]uint64) bool {
+	if len(bits.data) != len(*data) {
+		return false
+	}
+	for i := 0; i < len(bits.data); i++ {
+		for {
+			old := bits.data[i]
+			new := bits.data[i] | (*data)[i]
+			if old == new {
+				break
+			}
+			if atomic.CompareAndSwapUint64(&bits.data[i], old, new) {
+				break
+			}
+		}
+	}
+	return true
+}
+
+func bitCount(i uint64) uint64 {
+	var c uint64
+	for ; i != 0; i = i >> 1 {
+		if i&1 == 1 {
+			c++
+		}
+	}
+	return c
+}

vendor/github.com/Dai0522/go-hash/bloomfilter/bloomfilter.go

@@ -0,0 +1,173 @@
+package bloomfilter
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"math"
+
+	"github.com/Dai0522/go-hash/murmur3"
+)
+
+// BloomFilter .
+type BloomFilter struct {
+	strategy Strategy
+	bits     Bitmap
+	numHash  int
+}
+
+// New BloomFilter
+func New(expect uint64, fpp float64) (*BloomFilter, error) {
+	m := optimalNumOfBits(expect, fpp)
+	b, err := NewLockFreeBitmap(m)
+	if err != nil {
+		return nil, err
+	}
+	return &BloomFilter{
+		strategy: &Murur3_128Strategy{
+			hashFunc: murmur3.New(),
+		},
+		bits:    b,
+		numHash: optimalNumOfHash(expect, m),
+	}, nil
+}
+
+// Put little endian byte array
+func (bf *BloomFilter) Put(b []byte) bool {
+	return bf.strategy.Put(b, bf.numHash, bf.bits)
+}
+
+// PutUint16 .
+func (bf *BloomFilter) PutUint16(i uint16) bool {
+	b := make([]byte, 4)
+	binary.LittleEndian.PutUint16(b, i)
+	return bf.strategy.Put(b, bf.numHash, bf.bits)
+}
+
+// PutUint32 .
+func (bf *BloomFilter) PutUint32(i uint32) bool {
+	b := make([]byte, 4)
+	binary.LittleEndian.PutUint32(b, i)
+	return bf.strategy.Put(b, bf.numHash, bf.bits)
+}
+
+// PutUint64 .
+func (bf *BloomFilter) PutUint64(i uint64) bool {
+	b := make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, i)
+	return bf.strategy.Put(b, bf.numHash, bf.bits)
+}
+
+// MightContain little endian byte array
+func (bf *BloomFilter) MightContain(b []byte) bool {
+	return bf.strategy.MightContain(b, bf.numHash, bf.bits)
+}
+
+// MightContainUint16 .
+func (bf *BloomFilter) MightContainUint16(i uint16) bool {
+	b := make([]byte, 4)
+	binary.LittleEndian.PutUint16(b, i)
+	return bf.strategy.MightContain(b, bf.numHash, bf.bits)
+}
+
+// MightContainUint32 .
+func (bf *BloomFilter) MightContainUint32(i uint32) bool {
+	b := make([]byte, 4)
+	binary.LittleEndian.PutUint32(b, i)
+	return bf.strategy.MightContain(b, bf.numHash, bf.bits)
+}
+
+// MightContainUint64 .
+func (bf *BloomFilter) MightContainUint64(i uint64) bool {
+	b := make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, i)
+	return bf.strategy.MightContain(b, bf.numHash, bf.bits)
+}
+
+// ExpectedFpp returns the probability that mightContain will erroneously
+// return true for an object that has not actually been put in
+func (bf *BloomFilter) ExpectedFpp() float64 {
+	return math.Pow(float64(bf.bits.BitCount())/float64(bf.bits.BitSize()), float64(bf.numHash))
+}
+
+// ApproximateElementCount returns an estimate for the total number of
+// distinct elements that have been added to this Bloom filter. This
+// approximation is reasonably accurate if it does not exceed the value
+// of that was used when constructing the filter
+func (bf *BloomFilter) ApproximateElementCount() int {
+	size := float64(bf.bits.BitSize())
+	count := float64(bf.bits.BitCount())
+	res := math.Log1p(-1*count/size) * size / float64(bf.numHash)
+	return int(math.Ceil(res + 0.5))
+}
+
+// Serialized serialized bloom filter
+func (bf *BloomFilter) Serialized() *[]byte {
+	// Serial form:
+	// 1 signed byte for the strategy
+	// 1 unsigned byte for the number of hash functions
+	// 1 big endian int, the number of longs in our bitset
+	// N big endian longs of our bitset
+	var buf bytes.Buffer
+	buf.WriteByte(byte(1))
+	buf.WriteByte(byte(bf.numHash))
+
+	size := make([]byte, 4)
+	binary.BigEndian.PutUint32(size, bf.bits.Size())
+	buf.Write(size)
+
+	dataBuf := make([]byte, 8)
+	data := *bf.bits.Data()
+	for _, v := range data {
+		binary.BigEndian.PutUint64(dataBuf, v)
+		buf.Write(dataBuf)
+	}
+
+	res := buf.Bytes()
+	return &res
+}
+
+// Load load serialized bloom filter into memory
+func Load(b *[]byte) (*BloomFilter, error) {
+	if len(*b) < 10 {
+		return nil, errors.New("invaled data")
+	}
+	numHash := int((*b)[1])
+	length := binary.BigEndian.Uint32((*b)[2:6])
+	data := make([]uint64, length)
+	for i := 0; i < int(length); i++ {
+		j := (i * 8) + 6
+		data[i] = binary.BigEndian.Uint64((*b)[j : j+8])
+	}
+	bits := LoadLockFreeBitmap(&data)
+
+	bf := &BloomFilter{
+		strategy: &Murur3_128Strategy{
+			hashFunc: murmur3.New(),
+		},
+		bits:    bits,
+		numHash: numHash,
+	}
+	return bf, nil
+}
+
+// Merge return dst bloom filter ptr
+func Merge(src *BloomFilter, dst *BloomFilter) *BloomFilter {
+	if src == nil || dst == nil {
+		return dst
+	}
+
+	dst.bits.Merge(src.bits.Data())
+	return dst
+}
+
+func optimalNumOfHash(n, m uint64) int {
+	return int(math.Max(1, math.Floor((float64(m/n)*math.Log(2))+0.5)))
+}
+
+func optimalNumOfBits(n uint64, p float64) uint64 {
+	if p == 0.0 {
+		p = math.SmallestNonzeroFloat64
+	}
+	return uint64(-1 * float64(n) * math.Log(p) / (math.Log(2) * math.Log(2)))
+}

vendor/github.com/Dai0522/go-hash/bloomfilter/strategies.go

@@ -0,0 +1,53 @@
+package bloomfilter
+
+import (
+	"encoding/binary"
+	"math"
+
+	"github.com/Dai0522/go-hash/murmur3"
+)
+
+// Strategy .
+type Strategy interface {
+	Put([]byte, int, Bitmap) bool
+	MightContain([]byte, int, Bitmap) bool
+}
+
+// Murur3_128Strategy .
+type Murur3_128Strategy struct {
+	hashFunc *murmur3.Murmur3
+}
+
+// Put .
+func (s *Murur3_128Strategy) Put(b []byte, n int, bits Bitmap) bool {
+	bitSize := bits.BitSize()
+	hashCode := s.hashFunc.Murmur3_128(b)
+	h1 := binary.LittleEndian.Uint64(hashCode[:8])
+	h2 := binary.LittleEndian.Uint64(hashCode[8:])
+
+	bitsChanged := false
+	combine := h1
+	for i := 0; i < n; i++ {
+		res := bits.Set((combine & math.MaxInt64) % bitSize)
+		bitsChanged = bitsChanged || res
+		combine += h2
+	}
+	return bitsChanged
+}
+
+// MightContain .
+func (s *Murur3_128Strategy) MightContain(b []byte, n int, bits Bitmap) bool {
+	bitSize := bits.BitSize()
+	hashCode := s.hashFunc.Murmur3_128(b)
+	h1 := binary.LittleEndian.Uint64(hashCode[:8])
+	h2 := binary.LittleEndian.Uint64(hashCode[8:])
+
+	combine := h1
+	for i := 0; i < n; i++ {
+		if !bits.Get((combine & math.MaxInt64) % bitSize) {
+			return false
+		}
+		combine += h2
+	}
+	return true
+}

vendor/github.com/Dai0522/go-hash/murmur3/BUILD.bazel

@@ -0,0 +1,28 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "murmur3.go",
+        "murmur3_128.go",
+        "murmur3_32.go",
+        "murmur3_64.go",
+    ],
+    importmap = "go-common/vendor/github.com/Dai0522/go-hash/murmur3",
+    importpath = "github.com/Dai0522/go-hash/murmur3",
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/Dai0522/go-hash/murmur3/murmur3.go

@@ -0,0 +1,39 @@
+package murmur3
+
+// Murmur3 .
+type Murmur3 struct {
+	seed uint32
+}
+
+// New .
+func New() *Murmur3 {
+	return NewWithSeed(0)
+}
+
+// NewWithSeed .
+func NewWithSeed(s uint32) *Murmur3 {
+	return &Murmur3{
+		seed: s,
+	}
+}
+
+// Murmur3_32 .
+func (h *Murmur3) Murmur3_32(b []byte) []byte {
+	return murmur3_32(h.seed, b)
+}
+
+// Murmur3_64 .
+func (h *Murmur3) Murmur3_64(b []byte) []byte {
+	return murmur3_64(h.seed, b)
+}
+
+// Murmur3_128 little endian []byte.
+func (h *Murmur3) Murmur3_128(b []byte) []byte {
+	h1, h2 := murmur3_128(h.seed, b)
+	return []byte{
+		byte(h1), byte(h1 >> 8), byte(h1 >> 16), byte(h1 >> 24),
+		byte(h1 >> 32), byte(h1 >> 40), byte(h1 >> 48), byte(h1 >> 56),
+		byte(h2), byte(h2 >> 8), byte(h2 >> 16), byte(h2 >> 24),
+		byte(h2 >> 32), byte(h2 >> 40), byte(h2 >> 48), byte(h2 >> 56),
+	}
+}

vendor/github.com/Dai0522/go-hash/murmur3/murmur3_128.go

@@ -0,0 +1,133 @@
+package murmur3
+
+import (
+	"unsafe"
+)
+
+const (
+	c1_128  = 0x87c37b91114253d5
+	c2_128  = 0x4cf5ad432745937f
+	size128 = 16
+)
+
+// murmur3_128
+func murmur3_128(seed uint32, b []byte) (uint64, uint64) {
+	h1 := uint64(seed)
+	h2 := uint64(seed)
+
+	length := len(b)
+	h1, h2 = bmix64(b, h1, h2)
+
+	// tail
+	tail := b[length-(length&15):]
+	var k1, k2 uint64
+	switch length & 15 {
+	case 15:
+		k2 ^= uint64(tail[14]) << 48
+		fallthrough
+	case 14:
+		k2 ^= uint64(tail[13]) << 40
+		fallthrough
+	case 13:
+		k2 ^= uint64(tail[12]) << 32
+		fallthrough
+	case 12:
+		k2 ^= uint64(tail[11]) << 24
+		fallthrough
+	case 11:
+		k2 ^= uint64(tail[10]) << 16
+		fallthrough
+	case 10:
+		k2 ^= uint64(tail[9]) << 8
+		fallthrough
+	case 9:
+		k2 ^= uint64(tail[8]) << 0
+		k2 *= c2_128
+		k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+		k2 *= c1_128
+		h2 ^= k2
+		fallthrough
+	case 8:
+		k1 ^= uint64(tail[7]) << 56
+		fallthrough
+	case 7:
+		k1 ^= uint64(tail[6]) << 48
+		fallthrough
+	case 6:
+		k1 ^= uint64(tail[5]) << 40
+		fallthrough
+	case 5:
+		k1 ^= uint64(tail[4]) << 32
+		fallthrough
+	case 4:
+		k1 ^= uint64(tail[3]) << 24
+		fallthrough
+	case 3:
+		k1 ^= uint64(tail[2]) << 16
+		fallthrough
+	case 2:
+		k1 ^= uint64(tail[1]) << 8
+		fallthrough
+	case 1:
+		k1 ^= uint64(tail[0]) << 0
+		k1 *= c1_128
+		k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+		k1 *= c2_128
+		h1 ^= k1
+	}
+
+	h1 ^= uint64(length)
+	h2 ^= uint64(length)
+
+	h1 += h2
+	h2 += h1
+
+	h1 = fmix64(h1)
+	h2 = fmix64(h2)
+
+	h1 += h2
+	h2 += h1
+	return h1, h2
+}
+
+// bmix64 .
+func bmix64(b []byte, h1, h2 uint64) (uint64, uint64) {
+	nblocks := len(b) / 16
+
+	// body
+	for i := 0; i < nblocks; i++ {
+		t := (*[2]uint64)(unsafe.Pointer(&b[i*16]))
+		k1, k2 := t[0], t[1]
+
+		k1 *= c1_128
+		k1 = (k1 << 31) | (k1 >> 33) // rotl64(k1, 31)
+		k1 *= c2_128
+		h1 ^= k1
+
+		h1 = (h1 << 27) | (h1 >> 37) // rotl64(h1, 27)
+		h1 += h2
+		h1 = h1*5 + 0x52dce729
+
+		k2 *= c2_128
+		k2 = (k2 << 33) | (k2 >> 31) // rotl64(k2, 33)
+		k2 *= c1_128
+		h2 ^= k2
+
+		h2 = (h2 << 31) | (h2 >> 33) // rotl64(h2, 31)
+		h2 += h1
+		h2 = h2*5 + 0x38495ab5
+	}
+
+	return h1, h2
+}
+
+// fmix64 .
+func fmix64(k uint64) uint64 {
+	k ^= k >> 33
+	k *= 0xff51afd7ed558ccd
+	k ^= k >> 33
+	k *= 0xc4ceb9fe1a85ec53
+	k ^= k >> 33
+
+	return k
+}

vendor/github.com/Dai0522/go-hash/murmur3/murmur3_32.go

@@ -0,0 +1,6 @@
+package murmur3
+
+func murmur3_32(seed uint32, b []byte) []byte {
+	// TODO: implement
+	return b
+}

vendor/github.com/Dai0522/go-hash/murmur3/murmur3_64.go

@@ -0,0 +1,6 @@
+package murmur3
+
+func murmur3_64(seed uint32, b []byte) []byte {
+	// TODO: implement
+	return b
+}

vendor/github.com/Dai0522/workpool/BUILD.bazel

@@ -0,0 +1,27 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "buffer.go",
+        "pool.go",
+        "task.go",
+    ],
+    importmap = "go-common/vendor/github.com/Dai0522/workpool",
+    importpath = "github.com/Dai0522/workpool",
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/Dai0522/workpool/README.md

@@ -0,0 +1,38 @@
+# workpool
+基于ringbuffer的无锁golang workpool  
+
+# usage
+```
+type TestTask struct {
+	name string
+}
+
+func (t *TestTask) Run() *[]byte {
+	fmt.Println(t.name)
+	res := []byte(t.name)
+	time.Sleep(time.Duration(1 * time.Second))
+	return &res
+}
+
+func createPool() *workpool.Pool {
+	conf := &workpool.PoolConfig{
+		MaxWorkers:     1024,
+		MaxIdleWorkers: 512,
+		MinIdleWorkers: 128,
+		KeepAlive:      time.Duration(30 * time.Second),
+	}
+	p, err := workpool.NewWorkerPool(1024, conf)
+	if err != nil {
+		panic(err)
+	}
+	p.Start()
+	return p
+}
+
+wp := createPool()
+ft := workpool.NewFutureTask(&TestTask{
+    name: "daiwei",
+})
+wp.Submit(ft)
+res, _ := ft.Wait(time.Duration(3 * time.Second))
+```

vendor/github.com/Dai0522/workpool/buffer.go

@@ -0,0 +1,82 @@
+package workpool
+
+import (
+	"errors"
+	"runtime"
+	"sync/atomic"
+)
+
+// ringBuffer .
+type ringBuffer struct {
+	capacity       uint64
+	mask           uint64
+	padding1       [7]uint64
+	lastCommintIdx uint64
+	padding2       [7]uint64
+	nextFreeIdx    uint64
+	padding3       [7]uint64
+	readerIdx      uint64
+	padding4       [7]uint64
+	slots          []*worker
+}
+
+// newRingBuffer .
+func newRingBuffer(c uint64) (*ringBuffer, error) {
+	if c == 0 || c&3 != 0 {
+		return nil, errors.New("capacity must be N power of 2")
+	}
+	return &ringBuffer{
+		lastCommintIdx: 0,
+		nextFreeIdx:    1,
+		readerIdx:      0,
+		capacity:       c,
+		mask:           c - 1,
+		slots:          make([]*worker, c),
+	}, nil
+}
+
+// push .
+func (r *ringBuffer) push(w *worker) error {
+	var head, tail, next uint64
+	for {
+		head = r.nextFreeIdx
+		tail = r.readerIdx
+		if (head > tail+r.capacity-2) || (head < tail-1) {
+			return errors.New("buffer is full")
+		}
+
+		next = (head + 1) & r.mask
+		if atomic.CompareAndSwapUint64(&r.nextFreeIdx, head, next) {
+			break
+		}
+		runtime.Gosched()
+	}
+	r.slots[head] = w
+
+	for !atomic.CompareAndSwapUint64(&r.lastCommintIdx, head-1, head) {
+		runtime.Gosched()
+	}
+	return nil
+}
+
+// pop .
+func (r *ringBuffer) pop() *worker {
+	var head, next uint64
+	for {
+		head = r.readerIdx
+		if head == r.lastCommintIdx {
+			return r.slots[head]
+		}
+		next = (head + 1) & r.mask
+		if atomic.CompareAndSwapUint64(&r.readerIdx, head, next) {
+			break
+		}
+		runtime.Gosched()
+	}
+	return r.slots[head]
+}
+
+// size .
+func (r *ringBuffer) size() uint64 {
+	return r.lastCommintIdx - r.readerIdx
+}

vendor/github.com/Dai0522/workpool/pool.go

@@ -0,0 +1,224 @@
+package workpool
+
+import (
+	"errors"
+	"runtime"
+	"sync"
+	"time"
+)
+
+const (
+	stateCreate   = 0
+	stateRunning  = 1
+	stateStopping = 2
+	stateShutdown = 3
+)
+
+// PoolConfig .
+type PoolConfig struct {
+	MaxWorkers     uint64
+	MaxIdleWorkers uint64
+	MinIdleWorkers uint64
+	KeepAlive      time.Duration
+}
+
+// Pool .
+type Pool struct {
+	conf       *PoolConfig
+	padding1   [8]uint64
+	ready      *ringBuffer
+	curWorkers uint64
+	padding2   [8]uint64
+	lock       sync.Mutex
+	state      uint8
+	stop       chan uint8
+}
+
+// worker .
+type worker struct {
+	id          uint64
+	lastUseTime time.Time
+	ftch        chan *FutureTask
+}
+
+var wChanCap = func() int {
+	// Use blocking worker if GOMAXPROCS=1.
+	// This immediately switches Serve to WorkerFunc, which results
+	// in higher performance (under go1.5 at least).
+	if runtime.GOMAXPROCS(0) == 1 {
+		return 0
+	}
+
+	// Use non-blocking worker if GOMAXPROCS>1,
+	// since otherwise the Serve caller (Acceptor) may lag accepting
+	// new task if WorkerFunc is CPU-bound.
+	return 1
+}()
+
+func newWorker(wid uint64) *worker {
+	return &worker{
+		id:          wid,
+		lastUseTime: time.Now(),
+		ftch:        make(chan *FutureTask, wChanCap),
+	}
+}
+
+// NewWorkerPool .
+func NewWorkerPool(capacity uint64, conf *PoolConfig) (p *Pool, err error) {
+	if capacity == 0 || capacity&3 != 0 {
+		err = errors.New("capacity must bigger than zero and N power of 2")
+		return
+	}
+
+	rb, err := newRingBuffer(capacity)
+	if err != nil {
+		return
+	}
+	p = &Pool{
+		conf:       conf,
+		ready:      rb,
+		curWorkers: 0,
+		state:      stateCreate,
+		stop:       make(chan uint8, 1),
+	}
+	return
+}
+
+func (p *Pool) changeState(old, new uint8) bool {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	if p.state != old {
+		return false
+	}
+
+	p.state = new
+	return true
+}
+
+// Start .
+func (p *Pool) Start() error {
+	if !p.changeState(stateCreate, stateRunning) {
+		return errors.New("workerpool already started")
+	}
+	go func() {
+		defer close(p.stop)
+		for {
+			p.clean()
+			select {
+			case <-p.stop:
+				p.cleanAll()
+				for !p.changeState(stateStopping, stateShutdown) {
+					runtime.Gosched()
+				}
+				return
+			default:
+				time.Sleep(p.conf.KeepAlive)
+			}
+		}
+	}()
+	return nil
+}
+
+// Stop .
+func (p *Pool) Stop() error {
+	if !p.changeState(stateRunning, stateStopping) {
+		return errors.New("workerpool is stopping")
+	}
+	p.stop <- stateStopping
+	return nil
+}
+
+// Submit .
+func (p *Pool) Submit(ft *FutureTask) error {
+	w, err := p.getReadyWorker()
+	if err != nil {
+		return err
+	}
+
+	w.ftch <- ft
+	return nil
+}
+
+// getReadyWorker .
+func (p *Pool) getReadyWorker() (w *worker, err error) {
+	w = p.ready.pop()
+	if w == nil {
+		p.lock.Lock()
+		workerID := p.curWorkers
+		if p.curWorkers >= p.conf.MaxWorkers {
+			err = errors.New("workerpool is full")
+			p.lock.Unlock()
+			return
+		}
+		p.curWorkers++
+		p.lock.Unlock()
+
+		w = newWorker(workerID)
+		go func(w *worker) {
+			for {
+				ft, ok := <-w.ftch
+				if !ok {
+					return
+				}
+				ft.out <- ft.T.Run()
+				p.release(w)
+			}
+		}(w)
+	}
+	return
+}
+
+// close worker
+func (p *Pool) close(w *worker) {
+	p.lock.Lock()
+	defer p.lock.Unlock()
+	if p.curWorkers > 0 {
+		p.curWorkers--
+	}
+	close(w.ftch)
+}
+
+// release  worker
+func (p *Pool) release(w *worker) {
+	if p.state > stateRunning {
+		p.close(w)
+		return
+	}
+	w.lastUseTime = time.Now()
+	if err := p.ready.push(w); err != nil {
+		p.close(w)
+	}
+}
+
+// clean: clean idle goroutine
+func (p *Pool) clean() {
+	for {
+		size := p.ready.size()
+		if size <= p.conf.MinIdleWorkers {
+			return
+		}
+
+		w := p.ready.pop()
+		if w == nil {
+			return
+		}
+
+		currentTime := time.Now()
+		if currentTime.Sub(w.lastUseTime) < p.conf.KeepAlive {
+			p.release(w)
+			return
+		}
+		p.close(w)
+	}
+}
+
+// cleanAll
+func (p *Pool) cleanAll() {
+	for {
+		w := p.ready.pop()
+		if w == nil {
+			return
+		}
+		p.release(w)
+	}
+}

vendor/github.com/Dai0522/workpool/task.go

@@ -0,0 +1,35 @@
+package workpool
+
+import (
+	"fmt"
+	"time"
+)
+
+// Task interface
+type Task interface {
+	Run() *[]byte
+}
+
+// FutureTask out must be blocking chan (size=0)
+type FutureTask struct {
+	T   Task
+	out chan *[]byte
+}
+
+// NewFutureTask .
+func NewFutureTask(t Task) *FutureTask {
+	return &FutureTask{
+		T:   t,
+		out: make(chan *[]byte, 1),
+	}
+}
+
+// Wait for task return until timeout
+func (ft *FutureTask) Wait(timeout time.Duration) (res *[]byte, err error) {
+	select {
+	case res = <-ft.out:
+	case <-time.After(timeout):
+		err = fmt.Errorf("task(%+v) timeout", ft)
+	}
+	return
+}

vendor/github.com/GRbit/go-pcre/BUILD.bazel

@@ -0,0 +1,25 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["pcre.go"],
+    cdeps = ["@pcre//:pcre"],
+    cgo = True,
+    importmap = "go-common/vendor/github.com/GRbit/go-pcre",
+    importpath = "github.com/GRbit/go-pcre",
+    visibility = ["//visibility:public"],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/GRbit/go-pcre/README.markdown

@@ -0,0 +1,35 @@
+go-pcre
+===============
+
+This is a Go language package providing Perl-Compatible RegularExpression
+support using libpcre or libpcre++.
+
+## documentation
+
+Use [godoc](https://godoc.org/github.com/GRbit/go-pcre).
+
+## installation
+
+1. install libpcre3-dev or libpcre++-dev
+
+2. go get
+
+```bash
+sudo apt-get install libpcre3-dev
+go get github.com/GRbit/go-pcre/
+```
+
+## usage
+
+Go programs that depend on this package should import this package as
+follows to allow automatic downloading:
+
+```go
+import (
+  "github.com/GRbit/go-pcre/"
+)
+```
+
+## LICENSE
+
+This is a fork of [go-pcre](https://github.com/pantsing/go-pcre).

vendor/github.com/GRbit/go-pcre/pcre.go

@@ -0,0 +1,783 @@
+// Copyright (c) 2011 Florian Weimer. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This package provides access to the Perl Compatible Regular
+// Expresion library, PCRE.
+//
+// It implements two main types, Regexp and Matcher. Regexp objects
+// store a compiled regular expression. They consist of two immutable
+// parts: pcre and pcre_extra. You can add pcre_exta to Compiled Regexp by
+// studying it with Study() function.
+// Compilation of regular expressions using Compile or MustCompile is
+// slightly expensive, so these objects should be kept and reused,
+// instead of compiling them from scratch for each matching attempt.
+// CompileJIT and MustCompileJIT are way more expensive then ordinary
+// methods, becose they run Study() func after Regexp compiled but gives
+// much better perfomance:
+// http://sljit.sourceforge.net/regex_perf.html
+//
+// Matcher objects keeps the results of a match against a []byte or
+// string subject. The Group and GroupString functions provide access
+// to capture groups; both versions work no matter if the subject was a
+// []byte or string.
+//
+// Matcher objects contain some temporary space and refer the original
+// subject. They are mutable and can be reused (using Match,
+// MatchString, Reset or ResetString).
+//
+// Most of Matcher.*String method are just links to []byte methods, so keep
+// this in mind.
+//
+// For details on the regular expression language implemented by this
+// package and the flags defined below, see the PCRE documentation.
+// http://www.pcre.org/pcre.txt
+package pcre
+
+/*
+#cgo pkg-config: libpcre
+#include <pcre.h>
+#include <string.h>
+*/
+import "C"
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+	"unsafe"
+)
+
+// Flags for Compile and Match functions.
+const (
+	ANCHORED        = C.PCRE_ANCHORED
+	BSR_ANYCRLF     = C.PCRE_BSR_ANYCRLF
+	BSR_UNICODE     = C.PCRE_BSR_UNICODE
+	NEWLINE_ANY     = C.PCRE_NEWLINE_ANY
+	NEWLINE_ANYCRLF = C.PCRE_NEWLINE_ANYCRLF
+	NEWLINE_CR      = C.PCRE_NEWLINE_CR
+	NEWLINE_CRLF    = C.PCRE_NEWLINE_CRLF
+	NEWLINE_LF      = C.PCRE_NEWLINE_LF
+	NO_UTF8_CHECK   = C.PCRE_NO_UTF8_CHECK
+)
+
+// Flags for Compile functions
+const (
+	CASELESS          = C.PCRE_CASELESS
+	DOLLAR_ENDONLY    = C.PCRE_DOLLAR_ENDONLY
+	DOTALL            = C.PCRE_DOTALL
+	DUPNAMES          = C.PCRE_DUPNAMES
+	EXTENDED          = C.PCRE_EXTENDED
+	EXTRA             = C.PCRE_EXTRA
+	FIRSTLINE         = C.PCRE_FIRSTLINE
+	JAVASCRIPT_COMPAT = C.PCRE_JAVASCRIPT_COMPAT
+	MULTILINE         = C.PCRE_MULTILINE
+	NO_AUTO_CAPTURE   = C.PCRE_NO_AUTO_CAPTURE
+	UNGREEDY          = C.PCRE_UNGREEDY
+	UTF8              = C.PCRE_UTF8
+	UCP               = C.PCRE_UCP
+)
+
+// Flags for Match functions
+const (
+	NOTBOL            = C.PCRE_NOTBOL
+	NOTEOL            = C.PCRE_NOTEOL
+	NOTEMPTY          = C.PCRE_NOTEMPTY
+	NOTEMPTY_ATSTART  = C.PCRE_NOTEMPTY_ATSTART
+	NO_START_OPTIMIZE = C.PCRE_NO_START_OPTIMIZE
+	PARTIAL_HARD      = C.PCRE_PARTIAL_HARD
+	PARTIAL_SOFT      = C.PCRE_PARTIAL_SOFT
+)
+
+// Flags for Study function
+const (
+	STUDY_JIT_COMPILE              = C.PCRE_STUDY_JIT_COMPILE
+	STUDY_JIT_PARTIAL_SOFT_COMPILE = C.PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE
+	STUDY_JIT_PARTIAL_HARD_COMPILE = C.PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE
+)
+
+// Flags for Config() fuction
+const (
+	CONFIG_JIT                    = C.PCRE_CONFIG_JIT
+	CONFIG_JITTARGET              = C.PCRE_CONFIG_JITTARGET
+	CONFIG_LINK_SIZE              = C.PCRE_CONFIG_LINK_SIZE
+	CONFIG_MATCH_LIMIT            = C.PCRE_CONFIG_MATCH_LIMIT
+	CONFIG_MATCH_LIMIT_RECURSION  = C.PCRE_CONFIG_MATCH_LIMIT_RECURSION
+	CONFIG_NEWLINE                = C.PCRE_CONFIG_NEWLINE
+	CONFIG_BSR                    = C.PCRE_CONFIG_BSR
+	CONFIG_POSIX_MALLOC_THRESHOLD = C.PCRE_CONFIG_POSIX_MALLOC_THRESHOLD
+	CONFIG_STACKRECURSE           = C.PCRE_CONFIG_STACKRECURSE
+	CONFIG_UTF16                  = C.PCRE_CONFIG_UTF16
+	CONFIG_UTF32                  = C.PCRE_CONFIG_UTF32
+	CONFIG_UTF8                   = C.PCRE_CONFIG_UTF8
+	CONFIG_UNICODE_PROPERTIES     = C.PCRE_CONFIG_UNICODE_PROPERTIES
+)
+
+// Exec-time and get/set-time error codes
+const (
+	ERROR_NOMATCH        = C.PCRE_ERROR_NOMATCH
+	ERROR_NULL           = C.PCRE_ERROR_NULL
+	ERROR_BADOPTION      = C.PCRE_ERROR_BADOPTION
+	ERROR_BADMAGIC       = C.PCRE_ERROR_BADMAGIC
+	ERROR_UNKNOWN_OPCODE = C.PCRE_ERROR_UNKNOWN_OPCODE
+	ERROR_UNKNOWN_NODE   = C.PCRE_ERROR_UNKNOWN_NODE
+	ERROR_NOMEMORY       = C.PCRE_ERROR_NOMEMORY
+	ERROR_NOSUBSTRING    = C.PCRE_ERROR_NOSUBSTRING
+	ERROR_MATCHLIMIT     = C.PCRE_ERROR_MATCHLIMIT
+	ERROR_CALLOUT        = C.PCRE_ERROR_CALLOUT
+	ERROR_BADUTF8        = C.PCRE_ERROR_BADUTF8
+	ERROR_BADUTF8_OFFSET = C.PCRE_ERROR_BADUTF8_OFFSET
+	ERROR_PARTIAL        = C.PCRE_ERROR_PARTIAL
+	ERROR_BADPARTIAL     = C.PCRE_ERROR_BADPARTIAL
+	ERROR_RECURSIONLIMIT = C.PCRE_ERROR_RECURSIONLIMIT
+	ERROR_INTERNAL       = C.PCRE_ERROR_INTERNAL
+	ERROR_BADCOUNT       = C.PCRE_ERROR_BADCOUNT
+	ERROR_JIT_STACKLIMIT = C.PCRE_ERROR_JIT_STACKLIMIT
+)
+
+// This function returns information about libpcre configuration.
+// Function passed flag f to C.pcre_config() func, and convert returned
+// vaule to string type.
+// http://www.pcre.org/original/doc/html/pcre_config.html
+func Config(f int) (r string) {
+	if f == C.PCRE_CONFIG_JITTARGET {
+		var jittarget *C.char
+		C.pcre_config(C.PCRE_CONFIG_JITTARGET, unsafe.Pointer(&jittarget))
+		r = C.GoString(jittarget)
+	} else {
+		var i C.int
+		C.pcre_config(C.int(f), unsafe.Pointer(&i))
+		r = fmt.Sprint(int32(i))
+	}
+	return
+}
+
+// This function returns string, which contains  all information
+// you can access by pcre_config() function
+func ConfigAll() (ret string) {
+	var i C.int
+	C.pcre_config(C.PCRE_CONFIG_JIT, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("jit: %d\n", int32(i))
+	var jittarget *C.char
+	C.pcre_config(C.PCRE_CONFIG_JITTARGET, unsafe.Pointer(&jittarget))
+	ret += fmt.Sprintf("jittarget: %s\n", C.GoString(jittarget))
+	C.pcre_config(C.PCRE_CONFIG_LINK_SIZE, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("link_size: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_MATCH_LIMIT, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("match_limit: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_MATCH_LIMIT_RECURSION, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("match_limit_recursion: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_NEWLINE, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("newline: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_BSR, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("bsr: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("posix_malloc_threshold: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_STACKRECURSE, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("stackrecurse: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_UTF16, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("utf16: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_UTF32, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("utf32: %d\n", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_UTF8, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("utf8: %d", int32(i))
+	C.pcre_config(C.PCRE_CONFIG_UNICODE_PROPERTIES, unsafe.Pointer(&i))
+	ret += fmt.Sprintf("unicode_properties: %d\n", int32(i))
+
+	return
+}
+
+// A reference to a compiled regular expression.
+// Use Compile or MustCompile to create such objects.
+type Regexp struct {
+	ptr   []byte
+	extra []byte
+}
+
+// Number of bytes in the compiled pattern
+func pcresize(ptr *C.pcre) (size C.size_t) {
+	C.pcre_fullinfo(ptr, nil, C.PCRE_INFO_SIZE, unsafe.Pointer(&size))
+	return
+}
+func pcreJITsize(ptr *C.pcre, ext *C.pcre_extra) (size C.size_t) {
+	C.pcre_fullinfo(ptr, ext, C.PCRE_INFO_JITSIZE, unsafe.Pointer(&size))
+	return
+}
+
+// Number of capture groups
+func pcregroups(ptr *C.pcre) (count C.int) {
+	C.pcre_fullinfo(ptr, nil,
+		C.PCRE_INFO_CAPTURECOUNT, unsafe.Pointer(&count))
+	return
+}
+
+// Returns string with regex pattern and int with fpcre flags.
+// Flags are specified before the regex in form like this "(?flags)regex"
+// Supported symbols i=CASELESS; m=MULTILINE; s=DOTALL; U=UNGREEDY; J=DUPNAMES;
+// x=EXTENDED; X=EXTRA; D=DOLLAR_ENDONLY; u=UTF8|UCP;
+func ParseFlags(ptr string) (string, int) {
+	fReg := MustCompile("^\\(\\?[a-zA-Z]+?\\)", 0)
+	flags := 0
+	for fStr := fReg.FindString(ptr, 0); fStr != ""; ptr = ptr[len(fStr):] {
+		fStr = fReg.FindString(ptr, 0)
+		if strings.Contains(fStr, "i") {
+			flags = flags | CASELESS
+		}
+		if strings.Contains(fStr, "D") {
+			flags = flags | DOLLAR_ENDONLY
+		}
+		if strings.Contains(fStr, "s") {
+			flags = flags | DOTALL
+		}
+		if strings.Contains(fStr, "J") {
+			flags = flags | DUPNAMES
+		}
+		if strings.Contains(fStr, "x") {
+			flags = flags | EXTENDED
+		}
+		if strings.Contains(fStr, "X") {
+			flags = flags | EXTRA
+		}
+		if strings.Contains(fStr, "m") {
+			flags = flags | MULTILINE
+		}
+		if strings.Contains(fStr, "U") {
+			flags = flags | UNGREEDY
+		}
+		if strings.Contains(fStr, "u") {
+			flags = flags | UTF8 | UCP
+		}
+	}
+	return ptr, flags
+}
+
+// Try to compile the pattern. If an error occurs, the second return
+// value is non-nil.
+func Compile(pattern string, flags int) (Regexp, error) {
+	patternC := C.CString(pattern)
+	defer C.free(unsafe.Pointer(patternC))
+	if clen := int(C.strlen(patternC)); clen != len(pattern) {
+		return Regexp{}, fmt.Errorf("%s (%d): %s",
+			pattern,
+			clen,
+			"NUL byte in pattern",
+		)
+	}
+	var errptr *C.char
+	var erroffset C.int
+	ptr := C.pcre_compile(patternC, C.int(flags), &errptr, &erroffset, nil)
+	if ptr == nil {
+		return Regexp{}, fmt.Errorf("%s (%d): %s",
+			pattern,
+			int(erroffset),
+			C.GoString(errptr),
+		)
+	}
+	defer C.free(unsafe.Pointer(ptr))
+	psize := pcresize(ptr)
+	var re Regexp
+	re.ptr = make([]byte, psize)
+	C.memcpy(unsafe.Pointer(&re.ptr[0]), unsafe.Pointer(ptr), psize)
+	return re, nil
+}
+
+// Try to parse flags of regex and compile it. If an error occurs,
+// the second return value is non-nil.
+func CompileParse(ptr string) (Regexp, error) {
+	ptr, f := ParseFlags(ptr)
+	retRegex, err := Compile(ptr, f)
+	if err != nil {
+		return Regexp{}, fmt.Errorf("can't compile/study pcre regexp: %s\nFlags:%b", ptr, f)
+	}
+	return retRegex, nil
+}
+
+// Compile pattern with jit compilation. flagC is Compile flags,
+// flagS is study flag.
+func CompileJIT(pattern string, flagsC, flagsS int) (Regexp, error) {
+	patternC := C.CString(pattern)
+	defer C.free(unsafe.Pointer(patternC))
+	if clen := int(C.strlen(patternC)); clen != len(pattern) {
+		return Regexp{}, fmt.Errorf("%s (%d): %s",
+			pattern,
+			clen,
+			"NUL byte in pattern",
+		)
+	}
+	var errptr *C.char
+	var erroffset C.int
+	ptr := C.pcre_compile(patternC, C.int(flagsC), &errptr, &erroffset, nil)
+	if ptr == nil {
+		return Regexp{}, fmt.Errorf("%s (%d): %s",
+			pattern,
+			int(erroffset),
+			C.GoString(errptr),
+		)
+	}
+	psize := pcresize(ptr)
+	var re Regexp
+	re.ptr = make([]byte, psize)
+	C.memcpy(unsafe.Pointer(&re.ptr[0]), unsafe.Pointer(ptr), psize)
+	errS := re.study(flagsS)
+	if errS != nil {
+		return re, fmt.Errorf("study error: %s", errS)
+	}
+	return re, nil
+}
+
+// Try to parse flags of regex and compile it with JIT optimization.
+// If an error occurs, the second return value is non-nil.
+func CompileParseJIT(ptr string, flags int) (Regexp, error) {
+	ptr, f := ParseFlags(ptr)
+	retRegex, err := CompileJIT(ptr, f, flags)
+	if err != nil {
+		return Regexp{}, fmt.Errorf("can't compile/study pcre regexp: %s\nFlags:%b\nFlagsJIT%b", ptr, f, flags)
+	}
+	return retRegex, nil
+}
+
+// Compile the pattern. If compilation fails, panic.
+func MustCompile(pattern string, flag int) (re Regexp) {
+	re, err := Compile(pattern, flag)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// CompileParse the pattern. If compilation fails, panic.
+func MustCompileParse(pattern string) (re Regexp) {
+	re, err := CompileParse(pattern)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// CompileJIT the pattern. If compilation fails, panic.
+func MustCompileJIT(pattern string, flagsC, flagsS int) (re Regexp) {
+	re, err := CompileJIT(pattern, flagsC, flagsS)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// CompileParseJIT the pattern. If compilation fails, panic.
+func MustCompileParseJIT(pattern string, flags int) (re Regexp) {
+	re, err := CompileParseJIT(pattern, flags)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Return the start and end of the first match.
+func (re *Regexp) FindAllIndex(bytes []byte, flags int) (r [][]int) {
+	m := re.Matcher(bytes, flags)
+	offset := 0
+	for m.Match(bytes[offset:], flags) {
+		r = append(r, []int{offset + int(m.ovector[0]), offset + int(m.ovector[1])})
+		offset += int(m.ovector[1])
+	}
+	return
+}
+
+// Return the start and end of the first match, or nil if no match.
+// loc[0] is the start and loc[1] is the end.
+func (re *Regexp) FindIndex(bytes []byte, flags int) []int {
+	m := re.Matcher(bytes, flags)
+	if m.Matches {
+		return []int{int(m.ovector[0]), int(m.ovector[1])}
+	}
+	return nil
+}
+
+// Return the start and end of the first match, or nil if no match.
+// loc[0] is the start and loc[1] is the end.
+func (re *Regexp) FindString(s string, flags int) string {
+	m := re.Matcher([]byte(s), flags)
+	if m.Matches {
+		return s[int(m.ovector[0]):int(m.ovector[1])]
+	}
+	return ""
+}
+
+// Returns the number of capture groups in the compiled regexp pattern.
+func (re Regexp) Groups() int {
+	if re.ptr == nil {
+		panic("Regexp.Groups: uninitialized")
+	}
+	return int(pcregroups((*C.pcre)(unsafe.Pointer(&re.ptr[0]))))
+}
+
+// Tries to match the speficied byte array slice to the current pattern.
+// Returns true if the match succeeds.
+func (r *Regexp) Match(subject []byte, flags int) bool {
+	m := r.Matcher(subject, flags)
+	return m.Matches
+}
+
+// Same as Match, but accept string as argument
+func (r *Regexp) MatchString(subject string, flags int) bool {
+	m := r.Matcher([]byte(subject), flags)
+	return m.Matches
+}
+
+// Returns a new matcher object, with the byte array slice as a
+// subject.
+func (re Regexp) Matcher(subject []byte, flags int) (m *Matcher) {
+	m = new(Matcher)
+	m.Reset(re, subject, flags)
+	return
+}
+
+// Returns a new matcher object, with the specified subject string.
+func (re Regexp) MatcherString(subject string, flags int) (m *Matcher) {
+	m = new(Matcher)
+	m.ResetString(re, subject, flags)
+	return
+}
+
+// Return a copy of a byte slice with pattern matches replaced by repl.
+func (re Regexp) ReplaceAll(bytes, repl []byte, flags int) []byte {
+	m := re.Matcher(bytes, 0)
+	r := []byte{}
+	for m.Match(bytes, flags) {
+		r = append(append(r, bytes[:m.ovector[0]]...), repl...)
+		bytes = bytes[m.ovector[1]:]
+	}
+	return append(r, bytes...)
+}
+
+// Same as ReplaceAll, but accept strings as arguments
+func (re Regexp) ReplaceAllString(src, repl string, flags int) string {
+	return string(re.ReplaceAll([]byte(src), []byte(repl), flags))
+}
+
+// Study regexp and add pcre_extra information to it, which gives huge
+// speed boost when matching. If an error occurs, return value is
+// non-nil. If flags = 0, don't study at all and return error.
+// Studying can be quite a heavy optimization, but it's worth it.
+func (re *Regexp) study(flags int) error {
+	if re.extra != nil {
+		return fmt.Errorf("regexp already optimized")
+	}
+	if flags <= 0 {
+		return fmt.Errorf("flag must be > 0")
+	}
+	var err *C.char
+	extra := C.pcre_study((*C.pcre)(unsafe.Pointer(&re.ptr[0])), C.int(flags), &err)
+	if err != nil {
+		return fmt.Errorf(C.GoString(err))
+	}
+	defer C.free(unsafe.Pointer(extra))
+	size := pcreJITsize((*C.pcre)(unsafe.Pointer(&re.ptr[0])), extra)
+	if size > 0 {
+		re.extra = make([]byte, size)
+		C.memcpy(unsafe.Pointer(&re.extra[0]), unsafe.Pointer(extra), size)
+		return nil
+	} else {
+		return fmt.Errorf(C.GoString(err))
+	}
+}
+
+// Matcher objects provide a place for storing match results.
+// They can be created by the Matcher and MatcherString functions,
+// or they can be initialized with Reset or ResetString.
+type Matcher struct {
+	re       Regexp
+	Groups   int
+	ovector  []int32 // space for capture offsets, int32 is analogfor C.int type
+	Matches  bool    // last match was successful
+	Error    error   // pcre_exec error from last match
+	Partial  bool    // was the last match a partial match?
+	SubjectS string  // contain finded subject as string
+	SubjectB []byte  // contain finded subject as []byte
+}
+
+// Tries to match the speficied byte array slice to the current
+// pattern. Returns exec result.
+// C docs http://www.pcre.org/original/doc/html/pcre_exec.html
+func (m *Matcher) Exec(subject []byte, flags int) int {
+	if m.re.ptr == nil {
+		panic("Matcher.Match: uninitialized")
+	}
+	length := len(subject)
+	m.SubjectS = string(subject)
+	m.SubjectB = subject
+	if length == 0 {
+		subject = nullbyte // make first character adressable
+	}
+	subjectptr := (*C.char)(unsafe.Pointer(&subject[0]))
+	return m.exec(subjectptr, length, flags)
+}
+
+// Same as Exec, but accept string as argument
+func (m *Matcher) ExecString(subject string, flags int) int {
+	return m.Exec([]byte(subject), flags)
+}
+
+func (m *Matcher) exec(subjectptr *C.char, length, flags int) int {
+	var extra *C.pcre_extra
+	if m.re.extra != nil {
+		extra = (*C.pcre_extra)(unsafe.Pointer(&m.re.extra[0]))
+	} else {
+		extra = nil
+	}
+	rc := C.pcre_exec((*C.pcre)(unsafe.Pointer(&m.re.ptr[0])), extra,
+		subjectptr, C.int(length), 0, C.int(flags),
+		(*C.int)(unsafe.Pointer(&m.ovector[0])), C.int(len(m.ovector)))
+	return int(rc)
+}
+
+// Returns the captured string with submatches of the last match
+// (performed by Matcher, MatcherString, Reset, ResetString, Match,
+// or MatchString). Group 0 is the part of the subject which matches
+// the whole pattern; the first actual capture group is numbered 1.
+// Capture groups which are not present return a nil slice.
+func (m *Matcher) Extract() [][]byte {
+	if m.Matches {
+		captured_texts := make([][]byte, m.Groups+1)
+		captured_texts[0] = m.SubjectB
+		for i := 1; i < m.Groups+1; i++ {
+			start := m.ovector[2*i]
+			end := m.ovector[2*i+1]
+			captured_text := m.SubjectB[start:end]
+			captured_texts[i] = captured_text
+		}
+		return captured_texts
+	} else {
+		return nil
+	}
+}
+
+// Same as Extract, but returns []string
+func (m *Matcher) ExtractString() []string {
+	if m.Matches {
+		captured_texts := make([]string, m.Groups+1)
+		captured_texts[0] = m.SubjectS
+		for i := 1; i < m.Groups+1; i++ {
+			start := m.ovector[2*i]
+			end := m.ovector[2*i+1]
+			captured_text := m.SubjectS[start:end]
+			captured_texts[i] = captured_text
+		}
+		return captured_texts
+	} else {
+		return nil
+	}
+}
+
+func (m *Matcher) init(re Regexp) {
+	m.Matches = false
+	if m.re.ptr != nil && &m.re.ptr[0] == &re.ptr[0] {
+		// Skip group count extraction if the matcher has
+		// already been initialized with the same regular
+		// expression.
+		return
+	}
+	m.re = re
+	m.Groups = re.Groups()
+	if ovectorlen := 3 * (1 + m.Groups); len(m.ovector) < ovectorlen {
+		m.ovector = make([]int32, int32(ovectorlen))
+	}
+}
+
+var nullbyte = []byte{0}
+
+// Returns the numbered capture group of the last match (performed by
+// Matcher, MatcherString, Reset, ResetString, Match, or MatchString).
+// Group 0 is the part of the subject which matches the whole pattern;
+// the first actual capture group is numbered 1. Capture groups which
+// are not present return a nil slice.
+func (m *Matcher) Group(group int) []byte {
+	start := m.ovector[2*group]
+	end := m.ovector[2*group+1]
+	if start >= 0 {
+		return m.SubjectB[start:end]
+	}
+	return nil
+}
+
+// Returns the numbered capture group positions of the last match
+// (performed by Matcher, MatcherString, Reset, ResetString, Match,
+// or MatchString). Group 0 is the part of the subject which matches
+// the whole pattern; the first actual capture group is numbered 1.
+// Capture groups which are not present return a nil slice.
+func (m *Matcher) GroupIndices(group int) []int {
+	start := m.ovector[2*group]
+	end := m.ovector[2*group+1]
+	if start >= 0 {
+		return []int{int(start), int(end)}
+	}
+	return nil
+}
+
+// Same as Group, but returns string
+func (m *Matcher) GroupString(group int) string {
+	start := m.ovector[2*group]
+	end := m.ovector[2*group+1]
+	if start >= 0 {
+		return m.SubjectS[start:end]
+	}
+	return ""
+}
+
+// Index returns the start and end of the first match, if a previous
+// call to Matcher, MatcherString, Reset, ResetString, Match or
+// MatchString succeeded. loc[0] is the start and loc[1] is the end.
+func (m *Matcher) Index() []int {
+	if !m.Matches {
+		return nil
+	}
+
+	return []int{int(m.ovector[0]), int(m.ovector[1])}
+}
+
+// Tries to match the speficied byte array slice to the current
+// pattern. Returns true if the match succeeds.
+func (m *Matcher) Match(subject []byte, flags int) bool {
+	rc := m.Exec(subject, flags)
+	m.Matches, m.Error = checkMatch(rc)
+	m.Partial = (rc == C.PCRE_ERROR_PARTIAL)
+	return m.Matches
+}
+
+// Tries to match the speficied subject string to the current pattern.
+// Returns true if the match succeeds.
+func (m *Matcher) MatchString(subject string, flags int) bool {
+	rc := m.ExecString(subject, flags)
+	m.Matches, m.Error = checkMatch(rc)
+	m.Partial = (rc == ERROR_PARTIAL)
+	return m.Matches
+}
+
+func checkMatch(rc int) (bool, error) {
+	switch {
+	case rc >= 0 || rc == ERROR_PARTIAL:
+		return true, nil
+	case rc == ERROR_NOMATCH:
+		return false, nil
+	case rc == ERROR_NULL:
+		return false, fmt.Errorf("%d, pcre_exec: one or more variables passed to pcre_exec == NULL", ERROR_NULL)
+	case rc == ERROR_BADOPTION:
+		return false, fmt.Errorf("%d, pcre_exec: An unrecognized bit was set in the options argument", ERROR_BADOPTION)
+	case rc == ERROR_BADMAGIC:
+		return false, fmt.Errorf("%d, pcre_exec: invalid option flag", ERROR_BADMAGIC)
+	case rc == ERROR_UNKNOWN_OPCODE:
+		return false, fmt.Errorf("%d, pcre_exec: an unknown item was encountered in the compiled pattern", ERROR_UNKNOWN_OPCODE)
+	case rc == ERROR_NOMEMORY:
+		return false, fmt.Errorf("%d, pcre_exec: match limit", ERROR_NOMEMORY)
+	case rc == ERROR_MATCHLIMIT:
+		return false, fmt.Errorf("%d, pcre_exec: backtracking (match) limit was reached", ERROR_MATCHLIMIT)
+	case rc == ERROR_BADUTF8:
+		return false, fmt.Errorf("%d, pcre_exec: string that contains an invalid UTF-8 byte sequence was passed as a subject", ERROR_BADUTF8)
+	case rc == ERROR_RECURSIONLIMIT:
+		return false, fmt.Errorf("%d, pcre_exec: recursion limit", ERROR_RECURSIONLIMIT)
+	case rc == ERROR_JIT_STACKLIMIT:
+		return false, fmt.Errorf("%d, pcre_exec: error JIT stack limit", ERROR_JIT_STACKLIMIT)
+	case rc == ERROR_INTERNAL:
+		panic("pcre_exec: INTERNAL ERROR")
+	case rc == ERROR_BADCOUNT:
+		panic("pcre_exec: INTERNAL ERROR")
+	}
+	panic("unexepected return code from pcre_exec: " +
+		strconv.Itoa(int(rc)))
+}
+
+func (m *Matcher) name2index(name string) (group int, err error) {
+	if m.re.ptr == nil {
+		err = fmt.Errorf("Matcher.Named: uninitialized")
+		return
+	}
+	name1 := C.CString(name)
+	defer C.free(unsafe.Pointer(name1))
+	group = int(C.pcre_get_stringnumber(
+		(*C.pcre)(unsafe.Pointer(&m.re.ptr[0])), name1))
+	if group < 0 {
+		err = fmt.Errorf("Matcher.Named: unknown name: " + name)
+		return
+	}
+	return
+}
+
+// Returns the value of the named capture group. This is a nil slice
+// if the capture group is not present. Panics if the name does not
+// refer to a group.
+func (m *Matcher) Named(group string) (g []byte, err error) {
+	group_num, err := m.name2index(group)
+	if err != nil {
+		return
+	}
+	return m.Group(group_num), nil
+}
+
+// Returns true if the named capture group is present. Panics if the
+// name does not refer to a group.
+func (m *Matcher) NamedPresent(group string) (pres bool) {
+	group_num, err := m.name2index(group)
+	if err != nil {
+		return false
+	}
+	return m.Present(group_num)
+}
+
+// Returns the value of the named capture group, or an empty string if
+// the capture group is not present. Panics if the name does not
+// refer to a group.
+func (m *Matcher) NamedString(group string) (g string, err error) {
+	group_num, err := m.name2index(group)
+	if err != nil {
+		return
+	}
+	return m.GroupString(group_num), nil
+}
+
+// Returns true if the numbered capture group is present in the last
+// match (performed by Matcher, MatcherString, Reset, ResetString,
+// Match, or MatchString). Group numbers start at 1. A capture group
+// can be present and match the empty string.
+func (m *Matcher) Present(group int) bool {
+	return m.ovector[2*group] >= 0
+}
+
+// Switches the matcher object to the specified pattern and subject.
+func (m *Matcher) Reset(re Regexp, subject []byte, flags int) {
+	if re.ptr == nil {
+		panic("Regexp.Matcher: uninitialized")
+	}
+	m.init(re)
+	m.Match(subject, flags)
+}
+
+// Switches the matcher object to the specified pattern and subject
+// string.
+func (m *Matcher) ResetString(re Regexp, subject string, flags int) {
+	if re.ptr == nil {
+		panic("Regexp.Matcher: uninitialized")
+	}
+	m.init(re)
+	m.MatchString(subject, flags)
+}

vendor/github.com/Microsoft/go-winio/BUILD.bazel

@@ -0,0 +1,40 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "backup.go",
+        "ea.go",
+        "file.go",
+        "fileinfo.go",
+        "pipe.go",
+        "privilege.go",
+        "reparse.go",
+        "sd.go",
+        "syscall.go",
+        "zsyscall_windows.go",
+    ],
+    importmap = "go-common/vendor/github.com/Microsoft/go-winio",
+    importpath = "github.com/Microsoft/go-winio",
+    visibility = ["//visibility:public"],
+    deps = select({
+        "@io_bazel_rules_go//go/platform:windows": [
+            "//vendor/golang.org/x/sys/windows:go_default_library",
+        ],
+        "//conditions:default": [],
+    }),
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

vendor/github.com/Microsoft/go-winio/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Microsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

vendor/github.com/Microsoft/go-winio/README.md

@@ -0,0 +1,22 @@
+# go-winio
+
+This repository contains utilities for efficiently performing Win32 IO operations in
+Go. Currently, this is focused on accessing named pipes and other file handles, and
+for using named pipes as a net transport.
+
+This code relies on IO completion ports to avoid blocking IO on system threads, allowing Go
+to reuse the thread to schedule another goroutine. This limits support to Windows Vista and
+newer operating systems. This is similar to the implementation of network sockets in Go's net
+package.
+
+Please see the LICENSE file for licensing information.
+
+This project has adopted the [Microsoft Open Source Code of
+Conduct](https://opensource.microsoft.com/codeofconduct/). For more information
+see the [Code of Conduct
+FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact
+[opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional
+questions or comments.
+
+Thanks to natefinch for the inspiration for this library. See https://github.com/natefinch/npipe
+for another named pipe implementation.

vendor/github.com/Microsoft/go-winio/backup.go

@@ -0,0 +1,280 @@
+// +build windows
+
+package winio
+
+import (
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"runtime"
+	"syscall"
+	"unicode/utf16"
+)
+
+//sys backupRead(h syscall.Handle, b []byte, bytesRead *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupRead
+//sys backupWrite(h syscall.Handle, b []byte, bytesWritten *uint32, abort bool, processSecurity bool, context *uintptr) (err error) = BackupWrite
+
+const (
+	BackupData = uint32(iota + 1)
+	BackupEaData
+	BackupSecurity
+	BackupAlternateData
+	BackupLink
+	BackupPropertyData
+	BackupObjectId
+	BackupReparseData
+	BackupSparseBlock
+	BackupTxfsData
+)
+
+const (
+	StreamSparseAttributes = uint32(8)
+)
+
+const (
+	WRITE_DAC              = 0x40000
+	WRITE_OWNER            = 0x80000
+	ACCESS_SYSTEM_SECURITY = 0x1000000
+)
+
+// BackupHeader represents a backup stream of a file.
+type BackupHeader struct {
+	Id         uint32 // The backup stream ID
+	Attributes uint32 // Stream attributes
+	Size       int64  // The size of the stream in bytes
+	Name       string // The name of the stream (for BackupAlternateData only).
+	Offset     int64  // The offset of the stream in the file (for BackupSparseBlock only).
+}
+
+type win32StreamId struct {
+	StreamId   uint32
+	Attributes uint32
+	Size       uint64
+	NameSize   uint32
+}
+
+// BackupStreamReader reads from a stream produced by the BackupRead Win32 API and produces a series
+// of BackupHeader values.
+type BackupStreamReader struct {
+	r         io.Reader
+	bytesLeft int64
+}
+
+// NewBackupStreamReader produces a BackupStreamReader from any io.Reader.
+func NewBackupStreamReader(r io.Reader) *BackupStreamReader {
+	return &BackupStreamReader{r, 0}
+}
+
+// Next returns the next backup stream and prepares for calls to Read(). It skips the remainder of the current stream if
+// it was not completely read.
+func (r *BackupStreamReader) Next() (*BackupHeader, error) {
+	if r.bytesLeft > 0 {
+		if s, ok := r.r.(io.Seeker); ok {
+			// Make sure Seek on io.SeekCurrent sometimes succeeds
+			// before trying the actual seek.
+			if _, err := s.Seek(0, io.SeekCurrent); err == nil {
+				if _, err = s.Seek(r.bytesLeft, io.SeekCurrent); err != nil {
+					return nil, err
+				}
+				r.bytesLeft = 0
+			}
+		}
+		if _, err := io.Copy(ioutil.Discard, r); err != nil {
+			return nil, err
+		}
+	}
+	var wsi win32StreamId
+	if err := binary.Read(r.r, binary.LittleEndian, &wsi); err != nil {
+		return nil, err
+	}
+	hdr := &BackupHeader{
+		Id:         wsi.StreamId,
+		Attributes: wsi.Attributes,
+		Size:       int64(wsi.Size),
+	}
+	if wsi.NameSize != 0 {
+		name := make([]uint16, int(wsi.NameSize/2))
+		if err := binary.Read(r.r, binary.LittleEndian, name); err != nil {
+			return nil, err
+		}
+		hdr.Name = syscall.UTF16ToString(name)
+	}
+	if wsi.StreamId == BackupSparseBlock {
+		if err := binary.Read(r.r, binary.LittleEndian, &hdr.Offset); err != nil {
+			return nil, err
+		}
+		hdr.Size -= 8
+	}
+	r.bytesLeft = hdr.Size
+	return hdr, nil
+}
+
+// Read reads from the current backup stream.
+func (r *BackupStreamReader) Read(b []byte) (int, error) {
+	if r.bytesLeft == 0 {
+		return 0, io.EOF
+	}
+	if int64(len(b)) > r.bytesLeft {
+		b = b[:r.bytesLeft]
+	}
+	n, err := r.r.Read(b)
+	r.bytesLeft -= int64(n)
+	if err == io.EOF {
+		err = io.ErrUnexpectedEOF
+	} else if r.bytesLeft == 0 && err == nil {
+		err = io.EOF
+	}
+	return n, err
+}
+
+// BackupStreamWriter writes a stream compatible with the BackupWrite Win32 API.
+type BackupStreamWriter struct {
+	w         io.Writer
+	bytesLeft int64
+}
+
+// NewBackupStreamWriter produces a BackupStreamWriter on top of an io.Writer.
+func NewBackupStreamWriter(w io.Writer) *BackupStreamWriter {
+	return &BackupStreamWriter{w, 0}
+}
+
+// WriteHeader writes the next backup stream header and prepares for calls to Write().
+func (w *BackupStreamWriter) WriteHeader(hdr *BackupHeader) error {
+	if w.bytesLeft != 0 {
+		return fmt.Errorf("missing %d bytes", w.bytesLeft)
+	}
+	name := utf16.Encode([]rune(hdr.Name))
+	wsi := win32StreamId{
+		StreamId:   hdr.Id,
+		Attributes: hdr.Attributes,
+		Size:       uint64(hdr.Size),
+		NameSize:   uint32(len(name) * 2),
+	}
+	if hdr.Id == BackupSparseBlock {
+		// Include space for the int64 block offset
+		wsi.Size += 8
+	}
+	if err := binary.Write(w.w, binary.LittleEndian, &wsi); err != nil {
+		return err
+	}
+	if len(name) != 0 {
+		if err := binary.Write(w.w, binary.LittleEndian, name); err != nil {
+			return err
+		}
+	}
+	if hdr.Id == BackupSparseBlock {
+		if err := binary.Write(w.w, binary.LittleEndian, hdr.Offset); err != nil {
+			return err
+		}
+	}
+	w.bytesLeft = hdr.Size
+	return nil
+}
+
+// Write writes to the current backup stream.
+func (w *BackupStreamWriter) Write(b []byte) (int, error) {
+	if w.bytesLeft < int64(len(b)) {
+		return 0, fmt.Errorf("too many bytes by %d", int64(len(b))-w.bytesLeft)
+	}
+	n, err := w.w.Write(b)
+	w.bytesLeft -= int64(n)
+	return n, err
+}
+
+// BackupFileReader provides an io.ReadCloser interface on top of the BackupRead Win32 API.
+type BackupFileReader struct {
+	f               *os.File
+	includeSecurity bool
+	ctx             uintptr
+}
+
+// NewBackupFileReader returns a new BackupFileReader from a file handle. If includeSecurity is true,
+// Read will attempt to read the security descriptor of the file.
+func NewBackupFileReader(f *os.File, includeSecurity bool) *BackupFileReader {
+	r := &BackupFileReader{f, includeSecurity, 0}
+	return r
+}
+
+// Read reads a backup stream from the file by calling the Win32 API BackupRead().
+func (r *BackupFileReader) Read(b []byte) (int, error) {
+	var bytesRead uint32
+	err := backupRead(syscall.Handle(r.f.Fd()), b, &bytesRead, false, r.includeSecurity, &r.ctx)
+	if err != nil {
+		return 0, &os.PathError{"BackupRead", r.f.Name(), err}
+	}
+	runtime.KeepAlive(r.f)
+	if bytesRead == 0 {
+		return 0, io.EOF
+	}
+	return int(bytesRead), nil
+}
+
+// Close frees Win32 resources associated with the BackupFileReader. It does not close
+// the underlying file.
+func (r *BackupFileReader) Close() error {
+	if r.ctx != 0 {
+		backupRead(syscall.Handle(r.f.Fd()), nil, nil, true, false, &r.ctx)
+		runtime.KeepAlive(r.f)
+		r.ctx = 0
+	}
+	return nil
+}
+
+// BackupFileWriter provides an io.WriteCloser interface on top of the BackupWrite Win32 API.
+type BackupFileWriter struct {
+	f               *os.File
+	includeSecurity bool
+	ctx             uintptr
+}
+
+// NewBackupFileWriter returns a new BackupFileWriter from a file handle. If includeSecurity is true,
+// Write() will attempt to restore the security descriptor from the stream.
+func NewBackupFileWriter(f *os.File, includeSecurity bool) *BackupFileWriter {
+	w := &BackupFileWriter{f, includeSecurity, 0}
+	return w
+}
+
+// Write restores a portion of the file using the provided backup stream.
+func (w *BackupFileWriter) Write(b []byte) (int, error) {
+	var bytesWritten uint32
+	err := backupWrite(syscall.Handle(w.f.Fd()), b, &bytesWritten, false, w.includeSecurity, &w.ctx)
+	if err != nil {
+		return 0, &os.PathError{"BackupWrite", w.f.Name(), err}
+	}
+	runtime.KeepAlive(w.f)
+	if int(bytesWritten) != len(b) {
+		return int(bytesWritten), errors.New("not all bytes could be written")
+	}
+	return len(b), nil
+}
+
+// Close frees Win32 resources associated with the BackupFileWriter. It does not
+// close the underlying file.
+func (w *BackupFileWriter) Close() error {
+	if w.ctx != 0 {
+		backupWrite(syscall.Handle(w.f.Fd()), nil, nil, true, false, &w.ctx)
+		runtime.KeepAlive(w.f)
+		w.ctx = 0
+	}
+	return nil
+}
+
+// OpenForBackup opens a file or directory, potentially skipping access checks if the backup
+// or restore privileges have been acquired.
+//
+// If the file opened was a directory, it cannot be used with Readdir().
+func OpenForBackup(path string, access uint32, share uint32, createmode uint32) (*os.File, error) {
+	winPath, err := syscall.UTF16FromString(path)
+	if err != nil {
+		return nil, err
+	}
+	h, err := syscall.CreateFile(&winPath[0], access, share, nil, createmode, syscall.FILE_FLAG_BACKUP_SEMANTICS|syscall.FILE_FLAG_OPEN_REPARSE_POINT, 0)
+	if err != nil {
+		err = &os.PathError{Op: "open", Path: path, Err: err}
+		return nil, err
+	}
+	return os.NewFile(uintptr(h), path), nil
+}

vendor/github.com/Microsoft/go-winio/ea.go

@@ -0,0 +1,137 @@
+package winio
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+)
+
+type fileFullEaInformation struct {
+	NextEntryOffset uint32
+	Flags           uint8
+	NameLength      uint8
+	ValueLength     uint16
+}
+
+var (
+	fileFullEaInformationSize = binary.Size(&fileFullEaInformation{})
+
+	errInvalidEaBuffer = errors.New("invalid extended attribute buffer")
+	errEaNameTooLarge  = errors.New("extended attribute name too large")
+	errEaValueTooLarge = errors.New("extended attribute value too large")
+)
+
+// ExtendedAttribute represents a single Windows EA.
+type ExtendedAttribute struct {
+	Name  string
+	Value []byte
+	Flags uint8
+}
+
+func parseEa(b []byte) (ea ExtendedAttribute, nb []byte, err error) {
+	var info fileFullEaInformation
+	err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &info)
+	if err != nil {
+		err = errInvalidEaBuffer
+		return
+	}
+
+	nameOffset := fileFullEaInformationSize
+	nameLen := int(info.NameLength)
+	valueOffset := nameOffset + int(info.NameLength) + 1
+	valueLen := int(info.ValueLength)
+	nextOffset := int(info.NextEntryOffset)
+	if valueLen+valueOffset > len(b) || nextOffset < 0 || nextOffset > len(b) {
+		err = errInvalidEaBuffer
+		return
+	}
+
+	ea.Name = string(b[nameOffset : nameOffset+nameLen])
+	ea.Value = b[valueOffset : valueOffset+valueLen]
+	ea.Flags = info.Flags
+	if info.NextEntryOffset != 0 {
+		nb = b[info.NextEntryOffset:]
+	}
+	return
+}
+
+// DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
+// buffer retrieved from BackupRead, ZwQueryEaFile, etc.
+func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
+	for len(b) != 0 {
+		ea, nb, err := parseEa(b)
+		if err != nil {
+			return nil, err
+		}
+
+		eas = append(eas, ea)
+		b = nb
+	}
+	return
+}
+
+func writeEa(buf *bytes.Buffer, ea *ExtendedAttribute, last bool) error {
+	if int(uint8(len(ea.Name))) != len(ea.Name) {
+		return errEaNameTooLarge
+	}
+	if int(uint16(len(ea.Value))) != len(ea.Value) {
+		return errEaValueTooLarge
+	}
+	entrySize := uint32(fileFullEaInformationSize + len(ea.Name) + 1 + len(ea.Value))
+	withPadding := (entrySize + 3) &^ 3
+	nextOffset := uint32(0)
+	if !last {
+		nextOffset = withPadding
+	}
+	info := fileFullEaInformation{
+		NextEntryOffset: nextOffset,
+		Flags:           ea.Flags,
+		NameLength:      uint8(len(ea.Name)),
+		ValueLength:     uint16(len(ea.Value)),
+	}
+
+	err := binary.Write(buf, binary.LittleEndian, &info)
+	if err != nil {
+		return err
+	}
+
+	_, err = buf.Write([]byte(ea.Name))
+	if err != nil {
+		return err
+	}
+
+	err = buf.WriteByte(0)
+	if err != nil {
+		return err
+	}
+
+	_, err = buf.Write(ea.Value)
+	if err != nil {
+		return err
+	}
+
+	_, err = buf.Write([]byte{0, 0, 0}[0 : withPadding-entrySize])
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
+// buffer for use with BackupWrite, ZwSetEaFile, etc.
+func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
+	var buf bytes.Buffer
+	for i := range eas {
+		last := false
+		if i == len(eas)-1 {
+			last = true
+		}
+
+		err := writeEa(&buf, &eas[i], last)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return buf.Bytes(), nil
+}

vendor/github.com/Microsoft/go-winio/file.go

@@ -0,0 +1,307 @@
+// +build windows
+
+package winio
+
+import (
+	"errors"
+	"io"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"syscall"
+	"time"
+)
+
+//sys cancelIoEx(file syscall.Handle, o *syscall.Overlapped) (err error) = CancelIoEx
+//sys createIoCompletionPort(file syscall.Handle, port syscall.Handle, key uintptr, threadCount uint32) (newport syscall.Handle, err error) = CreateIoCompletionPort
+//sys getQueuedCompletionStatus(port syscall.Handle, bytes *uint32, key *uintptr, o **ioOperation, timeout uint32) (err error) = GetQueuedCompletionStatus
+//sys setFileCompletionNotificationModes(h syscall.Handle, flags uint8) (err error) = SetFileCompletionNotificationModes
+
+type atomicBool int32
+
+func (b *atomicBool) isSet() bool { return atomic.LoadInt32((*int32)(b)) != 0 }
+func (b *atomicBool) setFalse()   { atomic.StoreInt32((*int32)(b), 0) }
+func (b *atomicBool) setTrue()    { atomic.StoreInt32((*int32)(b), 1) }
+func (b *atomicBool) swap(new bool) bool {
+	var newInt int32
+	if new {
+		newInt = 1
+	}
+	return atomic.SwapInt32((*int32)(b), newInt) == 1
+}
+
+const (
+	cFILE_SKIP_COMPLETION_PORT_ON_SUCCESS = 1
+	cFILE_SKIP_SET_EVENT_ON_HANDLE        = 2
+)
+
+var (
+	ErrFileClosed = errors.New("file has already been closed")
+	ErrTimeout    = &timeoutError{}
+)
+
+type timeoutError struct{}
+
+func (e *timeoutError) Error() string   { return "i/o timeout" }
+func (e *timeoutError) Timeout() bool   { return true }
+func (e *timeoutError) Temporary() bool { return true }
+
+type timeoutChan chan struct{}
+
+var ioInitOnce sync.Once
+var ioCompletionPort syscall.Handle
+
+// ioResult contains the result of an asynchronous IO operation
+type ioResult struct {
+	bytes uint32
+	err   error
+}
+
+// ioOperation represents an outstanding asynchronous Win32 IO
+type ioOperation struct {
+	o  syscall.Overlapped
+	ch chan ioResult
+}
+
+func initIo() {
+	h, err := createIoCompletionPort(syscall.InvalidHandle, 0, 0, 0xffffffff)
+	if err != nil {
+		panic(err)
+	}
+	ioCompletionPort = h
+	go ioCompletionProcessor(h)
+}
+
+// win32File implements Reader, Writer, and Closer on a Win32 handle without blocking in a syscall.
+// It takes ownership of this handle and will close it if it is garbage collected.
+type win32File struct {
+	handle        syscall.Handle
+	wg            sync.WaitGroup
+	wgLock        sync.RWMutex
+	closing       atomicBool
+	readDeadline  deadlineHandler
+	writeDeadline deadlineHandler
+}
+
+type deadlineHandler struct {
+	setLock     sync.Mutex
+	channel     timeoutChan
+	channelLock sync.RWMutex
+	timer       *time.Timer
+	timedout    atomicBool
+}
+
+// makeWin32File makes a new win32File from an existing file handle
+func makeWin32File(h syscall.Handle) (*win32File, error) {
+	f := &win32File{handle: h}
+	ioInitOnce.Do(initIo)
+	_, err := createIoCompletionPort(h, ioCompletionPort, 0, 0xffffffff)
+	if err != nil {
+		return nil, err
+	}
+	err = setFileCompletionNotificationModes(h, cFILE_SKIP_COMPLETION_PORT_ON_SUCCESS|cFILE_SKIP_SET_EVENT_ON_HANDLE)
+	if err != nil {
+		return nil, err
+	}
+	f.readDeadline.channel = make(timeoutChan)
+	f.writeDeadline.channel = make(timeoutChan)
+	return f, nil
+}
+
+func MakeOpenFile(h syscall.Handle) (io.ReadWriteCloser, error) {
+	return makeWin32File(h)
+}
+
+// closeHandle closes the resources associated with a Win32 handle
+func (f *win32File) closeHandle() {
+	f.wgLock.Lock()
+	// Atomically set that we are closing, releasing the resources only once.
+	if !f.closing.swap(true) {
+		f.wgLock.Unlock()
+		// cancel all IO and wait for it to complete
+		cancelIoEx(f.handle, nil)
+		f.wg.Wait()
+		// at this point, no new IO can start
+		syscall.Close(f.handle)
+		f.handle = 0
+	} else {
+		f.wgLock.Unlock()
+	}
+}
+
+// Close closes a win32File.
+func (f *win32File) Close() error {
+	f.closeHandle()
+	return nil
+}
+
+// prepareIo prepares for a new IO operation.
+// The caller must call f.wg.Done() when the IO is finished, prior to Close() returning.
+func (f *win32File) prepareIo() (*ioOperation, error) {
+	f.wgLock.RLock()
+	if f.closing.isSet() {
+		f.wgLock.RUnlock()
+		return nil, ErrFileClosed
+	}
+	f.wg.Add(1)
+	f.wgLock.RUnlock()
+	c := &ioOperation{}
+	c.ch = make(chan ioResult)
+	return c, nil
+}
+
+// ioCompletionProcessor processes completed async IOs forever
+func ioCompletionProcessor(h syscall.Handle) {
+	for {
+		var bytes uint32
+		var key uintptr
+		var op *ioOperation
+		err := getQueuedCompletionStatus(h, &bytes, &key, &op, syscall.INFINITE)
+		if op == nil {
+			panic(err)
+		}
+		op.ch <- ioResult{bytes, err}
+	}
+}
+
+// asyncIo processes the return value from ReadFile or WriteFile, blocking until
+// the operation has actually completed.
+func (f *win32File) asyncIo(c *ioOperation, d *deadlineHandler, bytes uint32, err error) (int, error) {
+	if err != syscall.ERROR_IO_PENDING {
+		return int(bytes), err
+	}
+
+	if f.closing.isSet() {
+		cancelIoEx(f.handle, &c.o)
+	}
+
+	var timeout timeoutChan
+	if d != nil {
+		d.channelLock.Lock()
+		timeout = d.channel
+		d.channelLock.Unlock()
+	}
+
+	var r ioResult
+	select {
+	case r = <-c.ch:
+		err = r.err
+		if err == syscall.ERROR_OPERATION_ABORTED {
+			if f.closing.isSet() {
+				err = ErrFileClosed
+			}
+		}
+	case <-timeout:
+		cancelIoEx(f.handle, &c.o)
+		r = <-c.ch
+		err = r.err
+		if err == syscall.ERROR_OPERATION_ABORTED {
+			err = ErrTimeout
+		}
+	}
+
+	// runtime.KeepAlive is needed, as c is passed via native
+	// code to ioCompletionProcessor, c must remain alive
+	// until the channel read is complete.
+	runtime.KeepAlive(c)
+	return int(r.bytes), err
+}
+
+// Read reads from a file handle.
+func (f *win32File) Read(b []byte) (int, error) {
+	c, err := f.prepareIo()
+	if err != nil {
+		return 0, err
+	}
+	defer f.wg.Done()
+
+	if f.readDeadline.timedout.isSet() {
+		return 0, ErrTimeout
+	}
+
+	var bytes uint32
+	err = syscall.ReadFile(f.handle, b, &bytes, &c.o)
+	n, err := f.asyncIo(c, &f.readDeadline, bytes, err)
+	runtime.KeepAlive(b)
+
+	// Handle EOF conditions.
+	if err == nil && n == 0 && len(b) != 0 {
+		return 0, io.EOF
+	} else if err == syscall.ERROR_BROKEN_PIPE {
+		return 0, io.EOF
+	} else {
+		return n, err
+	}
+}
+
+// Write writes to a file handle.
+func (f *win32File) Write(b []byte) (int, error) {
+	c, err := f.prepareIo()
+	if err != nil {
+		return 0, err
+	}
+	defer f.wg.Done()
+
+	if f.writeDeadline.timedout.isSet() {
+		return 0, ErrTimeout
+	}
+
+	var bytes uint32
+	err = syscall.WriteFile(f.handle, b, &bytes, &c.o)
+	n, err := f.asyncIo(c, &f.writeDeadline, bytes, err)
+	runtime.KeepAlive(b)
+	return n, err
+}
+
+func (f *win32File) SetReadDeadline(deadline time.Time) error {
+	return f.readDeadline.set(deadline)
+}
+
+func (f *win32File) SetWriteDeadline(deadline time.Time) error {
+	return f.writeDeadline.set(deadline)
+}
+
+func (f *win32File) Flush() error {
+	return syscall.FlushFileBuffers(f.handle)
+}
+
+func (d *deadlineHandler) set(deadline time.Time) error {
+	d.setLock.Lock()
+	defer d.setLock.Unlock()
+
+	if d.timer != nil {
+		if !d.timer.Stop() {
+			<-d.channel
+		}
+		d.timer = nil
+	}
+	d.timedout.setFalse()
+
+	select {
+	case <-d.channel:
+		d.channelLock.Lock()
+		d.channel = make(chan struct{})
+		d.channelLock.Unlock()
+	default:
+	}
+
+	if deadline.IsZero() {
+		return nil
+	}
+
+	timeoutIO := func() {
+		d.timedout.setTrue()
+		close(d.channel)
+	}
+
+	now := time.Now()
+	duration := deadline.Sub(now)
+	if deadline.After(now) {
+		// Deadline is in the future, set a timer to wait
+		d.timer = time.AfterFunc(duration, timeoutIO)
+	} else {
+		// Deadline is in the past. Cancel all pending IO now.
+		timeoutIO()
+	}
+	return nil
+}