")
+}
+
+func TestRunShow_DescriptionFormatFallback(t *testing.T) {
+ t.Parallel()
+
+ // A legacy work item without the multilineFieldsFormat map is treated as
+ // Html, so the description is converted.
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(map[string]any{
+ "System.Description": "Bold intro",
+ })
+ stubTemplatePath(t, deps, wi, nil)
+
+ require.NoError(t, runShow(deps.cmd, showOpts("org:Fabrikam/12345")))
+ assert.Contains(t, deps.stdout.String(), "**Bold** intro")
+}
+
+func TestRunShow_DescriptionFormatFromPayload(t *testing.T) {
+ t.Parallel()
+
+ // The format is read from /multilineFieldsFormat/System.Description, not
+ // sniffed from content: HTML-looking content marked Markdown must not be
+ // converted (no markdown markers appear).
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(map[string]any{
+ "System.Description": "Bold intro",
+ })
+ format := map[string]string{"System.Description": "Markdown"}
+ stubTemplatePath(t, deps, wi, &format)
+
+ require.NoError(t, runShow(deps.cmd, showOpts("org:Fabrikam/12345")))
+
+ out := deps.stdout.String()
+ assert.Contains(t, out, "Bold")
+ assert.NotContains(t, out, "**Bold**")
+}
+
+func TestRunShow_TemplateOutput_NoDescription(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(nil)
+ stubTemplatePath(t, deps, wi, nil)
+
+ require.NoError(t, runShow(deps.cmd, showOpts("org:Fabrikam/12345")))
+ assert.Contains(t, deps.stdout.String(), "None given")
+}
+
+func TestRunShow_TemplateOutput_Tags(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(map[string]any{"System.Tags": "tag1; tag2"})
+ stubTemplatePath(t, deps, wi, nil)
+
+ require.NoError(t, runShow(deps.cmd, showOpts("org:Fabrikam/12345")))
+
+ out := deps.stdout.String()
+ assert.Contains(t, out, "tags:")
+ assert.Contains(t, out, "tag1; tag2")
+}
+
+func TestRunShow_TemplateOutput_NoTags(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(map[string]any{"System.Tags": ""})
+ stubTemplatePath(t, deps, wi, nil)
+
+ require.NoError(t, runShow(deps.cmd, showOpts("org:Fabrikam/12345")))
+ assert.NotContains(t, deps.stdout.String(), "tags:")
+}
+
+func TestRunShow_TemplateOutput_RelationsIncluded(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(nil)
+ wi.Relations = &[]workitemtracking.WorkItemRelation{
+ {Rel: types.ToPtr("System.LinkTypes.Hierarchy-Forward"), Url: types.ToPtr("https://dev.azure.com/myorg/Fabrikam/_apis/wit/workItems/12346")},
+ }
+ stubTemplatePath(t, deps, wi, nil)
+
+ opts := showOpts("org:Fabrikam/12345")
+ opts.showRelations = true
+ require.NoError(t, runShow(deps.cmd, opts))
+
+ out := deps.stdout.String()
+ assert.Contains(t, out, "relations:")
+ assert.Contains(t, out, "System.LinkTypes.Hierarchy-Forward")
+ assert.Contains(t, out, "workItems/12346")
+}
+
+func TestRunShow_TemplateOutput_RelationsOmitted_Default(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(nil)
+ wi.Relations = &[]workitemtracking.WorkItemRelation{
+ {Rel: types.ToPtr("System.LinkTypes.Hierarchy-Forward"), Url: types.ToPtr("https://dev.azure.com/myorg/Fabrikam/_apis/wit/workItems/12346")},
+ }
+ stubTemplatePath(t, deps, wi, nil)
+
+ require.NoError(t, runShow(deps.cmd, showOpts("org:Fabrikam/12345")))
+ assert.NotContains(t, deps.stdout.String(), "relations:")
+}
+
+func TestRunShow_TemplateOutput_CommentsIncluded(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(nil)
+ stubTemplatePath(t, deps, wi, nil)
+
+ createdDate := "2024-01-15T11:00:00Z"
+ comments := []workitemtracking.Comment{
+ {
+ CreatedBy: &webapi.IdentityRef{DisplayName: types.ToPtr("Alice")},
+ CreatedDate: types.ToPtr(mustParseTime(t, createdDate)),
+ Text: types.ToPtr("**note** about the login"),
+ },
+ }
+
+ deps.wit.EXPECT().GetComments(gomock.Any(), gomock.Any()).Return(
+ &workitemtracking.CommentList{Comments: &comments}, nil,
+ )
+
+ opts := showOpts("org:Fabrikam/12345")
+ opts.showComments = true
+ require.NoError(t, runShow(deps.cmd, opts))
+
+ out := deps.stdout.String()
+ assert.Contains(t, out, "comments:")
+ assert.Contains(t, out, "Alice")
+ assert.Contains(t, out, "commented")
+ assert.Contains(t, out, "**note** about the login")
+}
+
+func TestRunShow_TemplateOutput_CommentsOmitted_Default(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(nil)
+ stubTemplatePath(t, deps, wi, nil)
+ deps.wit.EXPECT().GetComments(gomock.Any(), gomock.Any()).Times(0)
+
+ require.NoError(t, runShow(deps.cmd, showOpts("org:Fabrikam/12345")))
+ assert.NotContains(t, deps.stdout.String(), "comments:")
+}
+
+func TestRunShow_JSONOutput(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(nil)
+ stubWit(deps)
+ stubWorkItem(t, deps, wi)
+
+ cmd := NewCmd(deps.cmd)
+ cmd.SetArgs([]string{"org:Fabrikam/12345", "--json"})
+ require.NoError(t, cmd.Execute())
+
+ out := deps.stdout.String()
+ for _, key := range []string{"id", "rev", "fields", "relations", "url", "_links", "commentVersionRef"} {
+ assert.Contains(t, out, `"`+key+`"`)
+ }
+ var parsed map[string]any
+ require.NoError(t, json.Unmarshal([]byte(out), &parsed))
+ assert.Equal(t, float64(12345), parsed["id"])
+ assert.Equal(t, float64(3), parsed["rev"])
+}
+
+func TestRunShow_ProjectScopeParsing(t *testing.T) {
+ t.Parallel()
+
+ tests := []struct {
+ name string
+ scopeArg string
+ wantError string
+ }{
+ {name: "explicit org", scopeArg: "myorg:Fabrikam/12345"},
+ {name: "implicit org", scopeArg: "Fabrikam/12345"},
+ {name: "legacy org slash rejected", scopeArg: "org/proj/extra", wantError: "legacy ORGANIZATION"},
+ {name: "empty input", scopeArg: "", wantError: "project is required"},
+ {name: "missing id", scopeArg: "Fabrikam", wantError: "targets"},
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "default-org")
+ if tc.wantError == "" {
+ wi := sampleShowWorkItem(nil)
+ stubTemplatePath(t, deps, wi, nil)
+ require.NoError(t, runShow(deps.cmd, showOpts(tc.scopeArg)))
+ } else {
+ err := runShow(deps.cmd, showOpts(tc.scopeArg))
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), tc.wantError)
+ }
+ })
+ }
+}
+
+func TestRunShow_InvalidProjectScope(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+
+ err := runShow(deps.cmd, showOpts("org/proj/extra"))
+ require.Error(t, err)
+ var flagErr *util.FlagError
+ require.ErrorAs(t, err, &flagErr)
+ assert.Contains(t, err.Error(), "legacy ORGANIZATION/... form is not supported")
+}
+
+func TestRunShow_ClientFactoryError(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ deps.clientFact.EXPECT().WorkItemTracking(gomock.Any(), gomock.Any()).
+ Return(nil, errors.New("factory boom"))
+
+ err := runShow(deps.cmd, showOpts("org:Fabrikam/12345"))
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "failed to create work item tracking client")
+}
+
+func TestRunShow_SDKError(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ stubWit(deps)
+ deps.wit.EXPECT().GetWorkItem(gomock.Any(), gomock.Any()).
+ Return(nil, errors.New("sdk boom"))
+
+ err := runShow(deps.cmd, showOpts("org:Fabrikam/12345"))
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "failed to get work item")
+}
+
+func TestRunShow_GetCommentsError(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(nil)
+ stubTemplatePath(t, deps, wi, nil)
+ deps.wit.EXPECT().GetComments(gomock.Any(), gomock.Any()).
+ Return(nil, errors.New("comments boom"))
+
+ opts := showOpts("org:Fabrikam/12345")
+ opts.showComments = true
+ err := runShow(deps.cmd, opts)
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "failed to get work item comments")
+}
+
+func TestRunShow_OrganizationFromConfigDefault(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "default-org")
+ wi := sampleShowWorkItem(nil)
+
+ var capturedOrg string
+ deps.clientFact.EXPECT().WorkItemTracking(gomock.Any(), gomock.Any()).
+ DoAndReturn(func(_ context.Context, org string) (workitemtracking.Client, error) {
+ capturedOrg = org
+ return deps.wit, nil
+ }).AnyTimes()
+ stubWorkItem(t, deps, wi)
+ stubEnvelope(t, deps, envelopeJSON(t, wi, nil))
+
+ require.NoError(t, runShow(deps.cmd, showOpts("Fabrikam/12345")))
+ assert.Equal(t, "default-org", capturedOrg)
+}
+
+func TestRunShow_WorkItemProjectMismatch(t *testing.T) {
+ t.Parallel()
+
+ deps := setupShowDeps(t, "org")
+ wi := sampleShowWorkItem(map[string]any{"System.TeamProject": "OtherProject"})
+ stubWit(deps)
+ stubWorkItem(t, deps, wi)
+
+ err := runShow(deps.cmd, showOpts("org:Fabrikam/12345"))
+ require.Error(t, err)
+ assert.Contains(t, err.Error(), "does not belong to project")
+ assert.Empty(t, deps.stdout.String())
+}
+
+func mustParseTime(t *testing.T, raw string) azuredevops.Time {
+ t.Helper()
+
+ parsed, err := time.Parse(time.RFC3339, raw)
+ require.NoError(t, err)
+ return azuredevops.Time{Time: parsed}
+}
diff --git a/internal/cmd/boards/workitem/workitem.go b/internal/cmd/boards/workitem/workitem.go
index 8fc7f6c1..af70fc65 100644
--- a/internal/cmd/boards/workitem/workitem.go
+++ b/internal/cmd/boards/workitem/workitem.go
@@ -6,6 +6,7 @@ import (
"github.com/tmeckel/azdo-cli/internal/cmd/boards/workitem/create"
"github.com/tmeckel/azdo-cli/internal/cmd/boards/workitem/delete"
"github.com/tmeckel/azdo-cli/internal/cmd/boards/workitem/list"
+ "github.com/tmeckel/azdo-cli/internal/cmd/boards/workitem/show"
"github.com/tmeckel/azdo-cli/internal/cmd/boards/workitem/update"
"github.com/tmeckel/azdo-cli/internal/cmd/util"
)
@@ -22,6 +23,9 @@ func NewCmd(ctx util.CmdContext) *cobra.Command {
# Create a work item
azdo boards work-item create Fabrikam --type Bug --title "Login is broken"
+ # Show a work item's details
+ azdo boards work-item show Fabrikam/42 --comments
+
# Update a work item's title
azdo boards work-item update Fabrikam/42 --title "New title"
@@ -32,6 +36,7 @@ func NewCmd(ctx util.CmdContext) *cobra.Command {
cmd.AddCommand(list.NewCmd(ctx))
cmd.AddCommand(create.NewCmd(ctx))
+ cmd.AddCommand(show.NewCmd(ctx))
cmd.AddCommand(update.NewCmd(ctx))
cmd.AddCommand(delete.NewCmd(ctx))
diff --git a/internal/cmd/pipelines/agent/show/show.go b/internal/cmd/pipelines/agent/show/show.go
index 466ef88c..d4735a0e 100644
--- a/internal/cmd/pipelines/agent/show/show.go
+++ b/internal/cmd/pipelines/agent/show/show.go
@@ -6,7 +6,6 @@ import (
"github.com/MakeNowJust/heredoc/v2"
"github.com/microsoft/azure-devops-go-api/azuredevops/v7/taskagent"
- "github.com/spewerspew/spew"
"github.com/spf13/cobra"
"go.uber.org/zap"
@@ -25,7 +24,6 @@ type templateData struct {
type showOptions struct {
targetArg string
includeCapabilities bool
- raw bool
exporter util.Exporter
}
@@ -71,7 +69,6 @@ func NewCmd(ctx util.CmdContext) *cobra.Command {
}
cmd.Flags().BoolVar(&opts.includeCapabilities, "include-capabilities", false, "Include system and user capabilities in the output")
- cmd.Flags().BoolVarP(&opts.raw, "raw", "r", false, "Dump raw agent object to stderr")
util.AddJSONFlags(cmd, &opts.exporter, []string{
"id", "name", "pool", "status", "enabled", "version", "osDescription",
"accessPoint", "provisioningState", "maxParallelism",
@@ -117,12 +114,6 @@ func runShow(cmdCtx util.CmdContext, opts *showOptions) error {
zap.Int("agentId", types.GetValue(agent.Id, 0)),
)
- if opts.raw {
- ios.StopProgressIndicator()
- spew.Dump(agent)
- return nil
- }
-
if opts.exporter != nil {
ios.StopProgressIndicator()
return opts.exporter.Write(ios, agent)
diff --git a/internal/cmd/pipelines/pool/show/show.go b/internal/cmd/pipelines/pool/show/show.go
index 258bdee1..cb19239f 100644
--- a/internal/cmd/pipelines/pool/show/show.go
+++ b/internal/cmd/pipelines/pool/show/show.go
@@ -6,7 +6,6 @@ import (
"github.com/MakeNowJust/heredoc/v2"
"github.com/microsoft/azure-devops-go-api/azuredevops/v7/taskagent"
- "github.com/spewerspew/spew"
"github.com/spf13/cobra"
"go.uber.org/zap"
@@ -22,7 +21,6 @@ type templateData struct {
type showOptions struct {
targetArg string
- raw bool
exporter util.Exporter
}
@@ -58,7 +56,6 @@ func NewCmd(ctx util.CmdContext) *cobra.Command {
},
}
- cmd.Flags().BoolVarP(&opts.raw, "raw", "r", false, "Dump raw pool object to stderr")
util.AddJSONFlags(cmd, &opts.exporter, []string{
"id", "name", "poolType", "isHosted", "isLegacy",
"autoProvision", "autoUpdate", "createdOn", "createdBy",
@@ -113,12 +110,6 @@ func runShow(cmdCtx util.CmdContext, opts *showOptions) error {
return fmt.Errorf("pool %q not found", poolTarget)
}
- if opts.raw {
- ios.StopProgressIndicator()
- spew.Dump(pool)
- return nil
- }
-
if opts.exporter != nil {
ios.StopProgressIndicator()
return opts.exporter.Write(ios, pool)
diff --git a/internal/cmd/pipelines/pool/show/show_test.go b/internal/cmd/pipelines/pool/show/show_test.go
index 6890d4e7..d5b9c8c5 100644
--- a/internal/cmd/pipelines/pool/show/show_test.go
+++ b/internal/cmd/pipelines/pool/show/show_test.go
@@ -395,20 +395,6 @@ func TestRunShow_JSONOutput(t *testing.T) {
assert.True(t, strings.HasPrefix(strings.TrimSpace(output), "{"))
}
-func TestRunShow_RawFlag(t *testing.T) {
- t.Parallel()
-
- deps := setupFakeDeps(t)
- deps.clientFact.EXPECT().TaskAgent(gomock.Any(), "myorg").Return(deps.taskClient, nil)
-
- pool := samplePool()
- deps.taskClient.EXPECT().GetAgentPool(gomock.Any(), gomock.Any()).Return(pool, nil)
-
- opts := &showOptions{targetArg: "myorg:/7", raw: true}
- err := runShow(deps.cmd, opts)
- require.NoError(t, err)
-}
-
func TestRunShow_ClientFactoryError(t *testing.T) {
t.Parallel()
@@ -516,9 +502,7 @@ func TestNewCmd_HasFlags(t *testing.T) {
t.Parallel()
cmd := NewCmd(nil)
- rawFlag := cmd.Flag("raw")
- require.NotNil(t, rawFlag)
- assert.Equal(t, "r", rawFlag.Shorthand)
+ assert.Nil(t, cmd.Flag("raw"))
jsonFlag := cmd.Flag("json")
require.NotNil(t, jsonFlag)
diff --git a/internal/cmd/pr/view/view.go b/internal/cmd/pr/view/view.go
index 16c41fcd..036437ae 100644
--- a/internal/cmd/pr/view/view.go
+++ b/internal/cmd/pr/view/view.go
@@ -12,7 +12,6 @@ import (
"github.com/google/uuid"
"github.com/microsoft/azure-devops-go-api/azuredevops/v7/git"
"github.com/microsoft/azure-devops-go-api/azuredevops/v7/identity"
- "github.com/spewerspew/spew"
"github.com/spf13/cobra"
"github.com/tmeckel/azdo-cli/internal/cmd/pr/shared"
"github.com/tmeckel/azdo-cli/internal/cmd/util"
@@ -24,7 +23,6 @@ type viewOptions struct {
selectorArg string
showComments bool
showCommits bool
- showRaw bool
commentType string
commentSort string
}
@@ -133,7 +131,6 @@ func NewCmd(ctx util.CmdContext) *cobra.Command {
cmd.Flags().BoolVarP(&opts.showComments, "comments", "c", false, "View pull request comments")
cmd.Flags().BoolVarP(&opts.showCommits, "commits", "C", false, "View pull request commits")
- cmd.Flags().BoolVarP(&opts.showRaw, "raw", "r", false, "View pull request raw")
util.StringEnumFlag(cmd, &opts.commentType, "comment-type", "", "text", []string{"text", "system", "all"}, "Filter comments by type; defaults to 'text'")
util.StringEnumFlag(cmd, &opts.commentSort, "comment-sort", "", "desc", []string{"desc", "asc"}, "Sort comments by creation time; defaults to 'desc' (newest first)")
util.AddJSONFlags(cmd, &opts.exporter, []string{
@@ -339,17 +336,6 @@ func runCmd(ctx util.CmdContext, opts *viewOptions) (err error) {
commits = &commitsResponse.Value
}
- if opts.showRaw {
- spew.Dump(pr)
- if threads != nil {
- spew.Dump(threads)
- }
- if commits != nil {
- spew.Dump(commits)
- }
- return nil
- }
-
if opts.exporter != nil {
prJSON := &pullRequestJSON{
URL: pr.Url,
diff --git a/scripts/checkin.sh b/scripts/checkin.sh
index ab03c51a..3aca43a6 100644
--- a/scripts/checkin.sh
+++ b/scripts/checkin.sh
@@ -46,17 +46,25 @@ commit_if_staged() {
fi
fi
- # The pre-commit hook may have modified files (e.g. an end-of-file
- # fixer). Re-stage exactly the files it touched and retry the commit.
- attempts=$((attempts + 1))
- if [[ $attempts -ge 5 ]]; then
- echo "Error: commit failed $attempts times; giving up. Inspect the working tree and re-run." >&2
- return 1
- fi
+ # Only retry when a pre-commit hook actually modified staged files
+ # (e.g. end-of-file fixer). A failing hook that changed nothing is a
+ # fatal error (e.g. yamllint): bail out instantly, never retry.
local modified
modified=$(git diff --name-only | grep -Fxf <(printf '%s\n' "$staged_before") || true)
if [[ -z "$modified" ]]; then
- echo "Error: commit failed and no staged files were modified by a hook; fix manually." >&2
+ echo "Error: pre-commit hook failed without modifying any staged file; aborting check-in." >&2
+ echo " Fix the failing hook and re-run." >&2
+ return 1
+ fi
+ if typos_hook_modified_file "$modified"; then
+ echo "Error: typos pre-commit hook modified staged files; aborting check-in, no retry." >&2
+ echo " Review the typo fixes, then re-run the check-in." >&2
+ return 1
+ fi
+
+ attempts=$((attempts + 1))
+ if [[ $attempts -ge 5 ]]; then
+ echo "Error: hooks modified files but the commit still failed $attempts times; giving up. Inspect the working tree and re-run." >&2
return 1
fi
echo "> pre-commit hook modified files; re-staging and retrying:"
@@ -66,6 +74,32 @@ commit_if_staged() {
done
}
+# Detect whether the typos pre-commit hook rewrote any of the given files.
+# A staged file whose working-tree version equals the staged version after
+# running typos in fix mode was rewritten by the hook. Typo fixes must be
+# reviewed deliberately, so callers abort instead of re-staging and retrying.
+typos_hook_modified_file() {
+ command -v typos >/dev/null 2>&1 || return 1
+ local cfg=()
+ if [ -f .typos.toml ]; then
+ cfg=(-c "$(pwd)/.typos.toml")
+ fi
+ local f staged_copy
+ while IFS= read -r f; do
+ [[ -n "$f" ]] || continue
+ staged_copy=$(mktemp)
+ if git show ":$f" > "$staged_copy" 2>/dev/null; then
+ typos --write-changes "${cfg[@]}" "$staged_copy" >/dev/null 2>&1 || true
+ if cmp -s "$staged_copy" "$f"; then
+ rm -f "$staged_copy"
+ return 0
+ fi
+ fi
+ rm -f "$staged_copy"
+ done <<< "$1"
+ return 1
+}
+
is_tracked() {
git ls-files --error-unmatch -- "$1" >/dev/null 2>&1
}
diff --git a/vendor/github.com/spewerspew/spew/.gitignore b/vendor/github.com/JohannesKaufmann/dom/.gitignore
similarity index 53%
rename from vendor/github.com/spewerspew/spew/.gitignore
rename to vendor/github.com/JohannesKaufmann/dom/.gitignore
index 064a5d49..6f6f5e6a 100644
--- a/vendor/github.com/spewerspew/spew/.gitignore
+++ b/vendor/github.com/JohannesKaufmann/dom/.gitignore
@@ -1,3 +1,6 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
# Binaries for programs and plugins
*.exe
*.exe~
@@ -11,9 +14,9 @@
# Output of the go coverage tool, specifically when used with LiteIDE
*.out
-# Common files using profiling
-*.cpu
-*.mem
-
# Dependency directories (remove the comment below to include it)
-# vendor/
\ No newline at end of file
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
diff --git a/vendor/github.com/JohannesKaufmann/dom/LICENSE b/vendor/github.com/JohannesKaufmann/dom/LICENSE
new file mode 100644
index 00000000..56507dcc
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Johannes Kaufmann
+
+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.
diff --git a/vendor/github.com/JohannesKaufmann/dom/README.md b/vendor/github.com/JohannesKaufmann/dom/README.md
new file mode 100644
index 00000000..bbc8ce6d
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/README.md
@@ -0,0 +1,277 @@
+# dom
+
+[](https://pkg.go.dev/github.com/JohannesKaufmann/dom)
+
+Helper functions for "net/html" that make it easier to interact with `*html.Node`.
+
+🚀 [Getting Started](#getting-started) - 📚 [Documentation](#documentation) - 🧑💻 [Examples](/examples/)
+
+## Installation
+
+```bash
+go get -u github.com/JohannesKaufmann/dom
+```
+
+> [!NOTE]
+> This "dom" libary was developed for the needs of the [html-to-markdown](https://github.com/JohannesKaufmann/html-to-markdown) library.
+> That beeing said, please submit any functions that you need.
+
+## Getting Started
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+ "strings"
+
+ "github.com/JohannesKaufmann/dom"
+ "golang.org/x/net/html"
+)
+
+func main() {
+ input := `
+
+ `
+
+ doc, err := html.Parse(strings.NewReader(input))
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ // - - - //
+
+ firstLink := dom.FindFirstNode(doc, func(node *html.Node) bool {
+ return dom.NodeName(node) == "a"
+ })
+
+ fmt.Println("href:", dom.GetAttributeOr(firstLink, "href", ""))
+}
+```
+
+## Node vs Element
+
+The naming scheme in this library is:
+
+- "Node" means `*html.Node{}`
+ - This means _any_ node in the tree of nodes.
+- "Element" means `*html.Node{Type: html.ElementNode}`
+ - This means _only_ nodes with the type of `ElementNode`. For example ``, ``, ``, ... but not `#text`, ``, ...
+
+For most functions, there are two versions. For example:
+
+- `FirstChildNode()` and `FirstChildElement()`
+- `AllChildNodes()` and `AllChildElements()`
+- ...
+
+## Documentation
+
+[](https://pkg.go.dev/github.com/JohannesKaufmann/dom)
+
+### Attributes & Content
+
+You can get the attributes of a node using `GetAttribute`, `GetAttributeOr` or the more specialized `GetClasses` that returns a slice of strings.
+
+For matching nodes, `HasID` and `HasClass` can be used.
+
+If you want to collect the #text of all the child nodes, you can call `CollectText`.
+
+```go
+name := dom.NodeName(node)
+// "h2"
+
+href := dom.GetAttributeOr(node, "href", "")
+// "github.com"
+
+isHeading := dom.HasClass(node, "repo__name")
+// `true`
+
+content := dom.CollectText(node)
+// "Lorem ipsum"
+```
+
+---
+
+### Children & Siblings
+
+You can already use `node.FirstChild` to get the first child _node_. For the convenience we added `FirstChildNode()` and `FirstChildElement()` which returns `*html.Node`.
+
+To get all direct children, use `AllChildNodes` and `AllChildElements` which returns `[]*html.Node`.
+
+- `PrevSiblingNode` and `PrevSiblingElement`
+
+- `NextSiblingNode` and `NextSiblingElement`
+
+### Find Nodes
+
+Searching for nodes deep in the tree is made easier with:
+
+```go
+firstParagraph := dom.FindFirstNode(doc, func(node *html.Node) bool {
+ return dom.NodeName(node) == "p"
+})
+// *html.Node
+
+
+allParagraphs := dom.FindAllNodes(doc, func(node *html.Node) bool {
+ return dom.NodeName(node) == "p"
+})
+// []*html.Node
+```
+
+- 🧑💻 [Example code, find](/examples/find/main.go)
+- 🧑💻 [Example code, selectors](/examples/selectors/main.go)
+
+---
+
+### Get next/previous neighbors
+
+What is special about this? The order!
+
+If you are somewhere in the DOM, you can call `GetNextNeighborNode` to get the next node, even if it is _further up_ the tree. The order is the same as you would see the elements in the DOM.
+
+```go
+node := startNode
+for node != nil {
+ fmt.Println(dom.NodeName(node))
+
+ node = dom.GetNextNeighborNode(node)
+}
+```
+
+If we start the `for` loop at the `` and repeatedly call `GetNextNeighborNode` this would be the _order_ that the nodes are _visited_.
+
+```text
+#document
+├─html
+│ ├─head
+│ ├─body
+│ │ ├─nav
+│ │ │ ├─p
+│ │ │ │ ├─#text "up"
+│ │ ├─main
+│ │ │ ├─button *️⃣
+│ │ │ │ ├─span 0️⃣
+│ │ │ │ │ ├─#text "start" 1️⃣
+│ │ │ ├─div 2️⃣
+│ │ │ │ ├─h3 3️⃣
+│ │ │ │ │ ├─#text "heading" 4️⃣
+│ │ │ │ ├─p 5️⃣
+│ │ │ │ │ ├─#text "description" 6️⃣
+│ │ ├─footer 7️⃣
+│ │ │ ├─p 8️⃣
+│ │ │ │ ├─#text "down" 9️⃣
+```
+
+If you only want to visit the ElementNode's (and skip the `#text` Nodes) you can use `GetNextNeighborElement` instead.
+
+If you want to skip the children you can use `GetNextNeighborNodeExcludingOwnChild`. In the example above, when starting at the `` the next node would be the ``.
+
+The same functions also exist for the previous nodes, e.g. `GetPrevNeighborNode`.
+
+- 🧑💻 [Example code, next basics](/examples/next_basics/main.go)
+- 🧑💻 [Example code, next inside a loop](/examples/next_loop/main.go)
+
+---
+
+### Remove & Replace Node
+
+```go
+if dom.HasClass(node, "lang__old") {
+ newNode := &html.Node{
+ Type: html.TextNode,
+ Data: "🪦",
+ }
+ dom.ReplaceNode(node, newNode)
+}
+
+
+for _, node := range emptyTextNodes {
+ dom.RemoveNode(node)
+}
+```
+
+- 🧑💻 [Example code, remove and replace](/examples/remove_replace/main.go)
+
+### Unwrap Node
+
+```text
+#document
+├─html
+│ ├─head
+│ ├─body
+│ │ ├─article *️⃣
+│ │ │ ├─h3
+│ │ │ │ ├─#text "Heading"
+│ │ │ ├─p
+│ │ │ │ ├─#text "short description"
+```
+
+If we take the input above and run `UnwrapNode(articleNode)` we can "unwrap" the `
`. That means removing the `` while _keeping_ the children (`` and ` `).
+
+```text
+#document
+├─html
+│ ├─head
+│ ├─body
+│ │ ├─h3
+│ │ │ ├─#text "Heading"
+│ │ ├─p
+│ │ │ ├─#text "short description"
+```
+
+For the reverse you can use `WrapNode(existingNode, newNode)`.
+
+---
+
+### RenderRepresentation
+
+```go
+import (
+ "fmt"
+ "log"
+ "strings"
+
+ "github.com/JohannesKaufmann/dom"
+ "golang.org/x/net/html"
+)
+
+func main() {
+ input := `Read More `
+
+ doc, err := html.Parse(strings.NewReader(input))
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ fmt.Println(dom.RenderRepresentation(doc))
+}
+```
+
+The tree representation helps to visualize the tree-structure of the DOM.
+And the `#text` nodes stand out.
+
+> [!TIP]
+> This function could be useful for debugging & testcases.
+> For example in [neighbors_test.go](/neighbors_test.go)
+
+```text
+#document
+├─html
+│ ├─head
+│ ├─body
+│ │ ├─a (href=/about)
+│ │ │ ├─#text "Read More"
+```
+
+While the normal "net/html" [`Render()`](https://pkg.go.dev/golang.org/x/net/html#Render) function would have produced this:
+
+```
+
Read More
+```
+
+- 🧑💻 [Example code, dom representation](/examples/dom_representation/main.go)
diff --git a/vendor/github.com/JohannesKaufmann/dom/attr.go b/vendor/github.com/JohannesKaufmann/dom/attr.go
new file mode 100644
index 00000000..5ea7b0b0
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/attr.go
@@ -0,0 +1,68 @@
+package dom
+
+import (
+ "bytes"
+ "strings"
+
+ "golang.org/x/net/html"
+)
+
+func GetAttribute(node *html.Node, key string) (string, bool) {
+ for _, attr := range node.Attr {
+ if attr.Key == key {
+ return attr.Val, true
+ }
+ }
+ return "", false
+}
+func GetAttributeOr(node *html.Node, key string, fallback string) string {
+ for _, attr := range node.Attr {
+ if attr.Key == key {
+ return attr.Val
+ }
+ }
+ return fallback
+}
+
+func GetClasses(node *html.Node) []string {
+ val, found := GetAttribute(node, "class")
+ if !found {
+ return nil
+ }
+
+ return strings.Fields(val)
+}
+
+func HasID(node *html.Node, expectedID string) bool {
+ val, found := GetAttribute(node, "id")
+ if !found {
+ return false
+ }
+ return strings.TrimSpace(val) == expectedID
+}
+func HasClass(node *html.Node, expectedClass string) bool {
+ classes := GetClasses(node)
+ for _, class := range classes {
+ if class == expectedClass {
+ return true
+ }
+ }
+ return false
+}
+
+// - - - - //
+
+func collectText(n *html.Node, buf *bytes.Buffer) {
+ if n.Type == html.TextNode {
+ buf.WriteString(n.Data)
+ }
+ for c := n.FirstChild; c != nil; c = c.NextSibling {
+ collectText(c, buf)
+ }
+}
+
+func CollectText(node *html.Node) string {
+ var buf bytes.Buffer
+ collectText(node, &buf)
+ return buf.String()
+}
diff --git a/vendor/github.com/JohannesKaufmann/dom/change.go b/vendor/github.com/JohannesKaufmann/dom/change.go
new file mode 100644
index 00000000..1b620f5a
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/change.go
@@ -0,0 +1,49 @@
+package dom
+
+import "golang.org/x/net/html"
+
+func RemoveNode(node *html.Node) {
+ if node == nil || node.Parent == nil {
+ return
+ }
+
+ node.Parent.RemoveChild(node)
+}
+
+func ReplaceNode(node, newNode *html.Node) {
+ if node.Parent == nil || node == newNode {
+ return
+ }
+
+ node.Parent.InsertBefore(newNode, node)
+ node.Parent.RemoveChild(node)
+}
+
+func UnwrapNode(node *html.Node) {
+ if node == nil || node.Parent == nil {
+ return
+ }
+
+ // In each iteration, we once again grab the first child, since
+ // the previous first child was just removed.
+ for child := node.FirstChild; child != nil; child = node.FirstChild {
+ node.RemoveChild(child)
+ node.Parent.InsertBefore(child, node)
+ }
+
+ node.Parent.RemoveChild(node)
+}
+
+// WrapNode wraps the newNode around the existingNode.
+func WrapNode(existingNode, newNode *html.Node) *html.Node {
+ if existingNode == nil || existingNode.Parent == nil {
+ return existingNode
+ }
+
+ existingNode.Parent.InsertBefore(newNode, existingNode)
+ existingNode.Parent.RemoveChild(existingNode)
+
+ newNode.AppendChild(existingNode)
+
+ return newNode
+}
diff --git a/vendor/github.com/JohannesKaufmann/dom/dom.go b/vendor/github.com/JohannesKaufmann/dom/dom.go
new file mode 100644
index 00000000..b39d6301
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/dom.go
@@ -0,0 +1,88 @@
+// dom makes it easier to interact with the html document.
+//
+// Node = return all the nodes
+// Element = return all the nodes that are of type Element. This e.g. excludes #text nodes.
+package dom
+
+import "golang.org/x/net/html"
+
+// AllNodes recursively gets all the nodes in the tree.
+func AllNodes(startNode *html.Node) (allNodes []*html.Node) {
+ var finder func(*html.Node)
+ finder = func(node *html.Node) {
+ allNodes = append(allNodes, node)
+
+ for child := node.FirstChild; child != nil; child = child.NextSibling {
+ finder(child)
+ }
+ }
+
+ finder(startNode)
+
+ return allNodes
+}
+
+// - - - - - - - - - - - - - - - //
+
+func AllChildNodes(node *html.Node) (children []*html.Node) {
+ for child := node.FirstChild; child != nil; child = child.NextSibling {
+ children = append(children, child)
+ }
+ return children
+}
+
+// AllChildElements is similar to AllChildNodes but only returns
+// nodes of type `ElementNode`.
+func AllChildElements(node *html.Node) (children []*html.Node) {
+ for child := node.FirstChild; child != nil; child = child.NextSibling {
+ if child.Type == html.ElementNode {
+ children = append(children, child)
+ }
+ }
+ return children
+}
+
+// - - - - - - - - - - - - - - - //
+
+func FirstChildNode(node *html.Node) *html.Node {
+ return node.FirstChild
+}
+func FirstChildElement(node *html.Node) *html.Node {
+ for child := node.FirstChild; child != nil; child = child.NextSibling {
+ if child.Type == html.ElementNode {
+ return child
+ }
+ }
+ return nil
+}
+
+// - - - - - - - - - - - - - - - //
+
+func PrevSiblingNode(node *html.Node) *html.Node {
+ return node.PrevSibling
+}
+func PrevSiblingElement(node *html.Node) *html.Node {
+ for sibling := node.PrevSibling; sibling != nil; sibling = sibling.PrevSibling {
+ if sibling.Type == html.ElementNode {
+ return sibling
+ }
+ }
+ return nil
+}
+
+// - - - - - - - - - - - - - - - //
+
+func NextSiblingNode(node *html.Node) *html.Node {
+ return node.NextSibling
+}
+
+// NextSiblingElement returns the element immediately following the passed-in node or nil.
+// In contrast to `node.NextSibling` this only returns the next `ElementNode`.
+func NextSiblingElement(node *html.Node) *html.Node {
+ for sibling := node.NextSibling; sibling != nil; sibling = sibling.NextSibling {
+ if sibling.Type == html.ElementNode {
+ return sibling
+ }
+ }
+ return nil
+}
diff --git a/vendor/github.com/JohannesKaufmann/dom/dom_representation.go b/vendor/github.com/JohannesKaufmann/dom/dom_representation.go
new file mode 100644
index 00000000..31757dd8
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/dom_representation.go
@@ -0,0 +1,64 @@
+package dom
+
+import (
+ "bytes"
+ "fmt"
+ "strings"
+
+ "golang.org/x/net/html"
+)
+
+func writePipeChar(buf *bytes.Buffer, index int) {
+ if index == 0 {
+ return
+ }
+ buf.WriteString(strings.Repeat("│ ", index-1))
+ buf.WriteString("├─")
+}
+func writeNode(buf *bytes.Buffer, node *html.Node) {
+ name := NodeName(node)
+ buf.WriteString(name)
+
+ if len(node.Attr) != 0 {
+ buf.WriteString(" (")
+ }
+ for i, attr := range node.Attr {
+ buf.WriteString(fmt.Sprintf("%s=%q", attr.Key, attr.Val))
+
+ if i < len(node.Attr)-1 {
+ buf.WriteString(" ")
+ }
+ }
+ if len(node.Attr) != 0 {
+ buf.WriteString(")")
+ }
+
+ if name == "#text" {
+ buf.WriteString(fmt.Sprintf(" %q", node.Data))
+ }
+
+}
+
+// RenderRepresentation is useful for debugging.
+// It renders out the *structure* of the dom.
+func RenderRepresentation(startNode *html.Node) string {
+ var buf bytes.Buffer
+ var finder func(*html.Node, int)
+ finder = func(node *html.Node, index int) {
+ writePipeChar(&buf, index)
+ writeNode(&buf, node)
+ buf.WriteRune('\n')
+
+ for child := node.FirstChild; child != nil; child = child.NextSibling {
+ finder(child, index+1)
+ }
+ }
+
+ if startNode.Parent == nil {
+ finder(startNode, 0)
+ } else {
+ finder(startNode, 1)
+ }
+
+ return strings.TrimSpace(buf.String())
+}
diff --git a/vendor/github.com/JohannesKaufmann/dom/find.go b/vendor/github.com/JohannesKaufmann/dom/find.go
new file mode 100644
index 00000000..29ddb22c
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/find.go
@@ -0,0 +1,49 @@
+package dom
+
+import "golang.org/x/net/html"
+
+func ContainsNode(startNode *html.Node, matchFn func(node *html.Node) bool) bool {
+ return FindFirstNode(startNode, matchFn) != nil
+}
+
+func FindFirstNode(startNode *html.Node, matchFn func(node *html.Node) bool) *html.Node {
+ nextFunc := UNSTABLE_initGetNeighbor(
+ FirstChildNode,
+ NextSiblingNode,
+ func(node *html.Node) bool {
+ // We should not get higher up than the startNode...
+ return node == startNode
+ },
+ )
+
+ child := startNode.FirstChild
+ for child != nil {
+ if matchFn(child) {
+ return child
+ }
+
+ child = nextFunc(child)
+ }
+ return nil
+}
+
+func FindAllNodes(startNode *html.Node, matchFn func(node *html.Node) bool) (foundNodes []*html.Node) {
+ nextFunc := UNSTABLE_initGetNeighbor(
+ FirstChildNode,
+ NextSiblingNode,
+ func(node *html.Node) bool {
+ // We should not get higher up than the startNode...
+ return node == startNode
+ },
+ )
+
+ child := startNode.FirstChild
+ for child != nil {
+ if matchFn(child) {
+ foundNodes = append(foundNodes, child)
+ }
+
+ child = nextFunc(child)
+ }
+ return foundNodes
+}
diff --git a/vendor/github.com/JohannesKaufmann/dom/neighbors.go b/vendor/github.com/JohannesKaufmann/dom/neighbors.go
new file mode 100644
index 00000000..4415443d
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/neighbors.go
@@ -0,0 +1,108 @@
+package dom
+
+import "golang.org/x/net/html"
+
+// Warning: It is not meant to be called directly and may change signature from release to release!
+func UNSTABLE_initGetNeighbor(
+ firstChildFunc func(node *html.Node) *html.Node,
+ prevNextFunc func(node *html.Node) *html.Node,
+ goUpUntilFunc func(node *html.Node) bool,
+) func(*html.Node) *html.Node {
+
+ return func(node *html.Node) *html.Node {
+ // First look at the children
+ if child := firstChildFunc(node); child != nil {
+ return child
+ }
+
+ // Otherwise my prev/next sibling
+ if sibling := prevNextFunc(node); sibling != nil {
+ return sibling
+ }
+
+ for {
+ // Finally, continously go upwards until we find an element with a sibling
+ node = node.Parent
+ if node == nil {
+ // We reached the top
+ return nil
+ }
+
+ if goUpUntilFunc(node) {
+ // Don't go too far up...
+ return nil
+ }
+
+ sibling := prevNextFunc(node)
+ if sibling != nil {
+ return sibling
+ }
+ }
+ }
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - //
+
+var goUpForever = func(node *html.Node) bool { return false }
+var skipFirstChild = func(node *html.Node) *html.Node { return nil }
+
+func GetPrevNeighborNode(node *html.Node) *html.Node {
+ return UNSTABLE_initGetNeighbor(
+ FirstChildNode,
+ PrevSiblingNode,
+ goUpForever,
+ )(node)
+}
+func GetPrevNeighborElement(node *html.Node) *html.Node {
+ return UNSTABLE_initGetNeighbor(
+ FirstChildElement,
+ PrevSiblingElement,
+ goUpForever,
+ )(node)
+}
+func GetPrevNeighborNodeExcludingOwnChild(node *html.Node) *html.Node {
+ return UNSTABLE_initGetNeighbor(
+ skipFirstChild,
+ PrevSiblingNode,
+ goUpForever,
+ )(node)
+}
+func GetPrevNeighborElementExcludingOwnChild(node *html.Node) *html.Node {
+ return UNSTABLE_initGetNeighbor(
+ skipFirstChild,
+ PrevSiblingElement,
+ goUpForever,
+ )(node)
+}
+
+// - - - - - - - - //
+
+func GetNextNeighborNode(node *html.Node) *html.Node {
+ return UNSTABLE_initGetNeighbor(
+ FirstChildNode,
+ NextSiblingNode,
+ goUpForever,
+ )(node)
+}
+func GetNextNeighborElement(node *html.Node) *html.Node {
+ return UNSTABLE_initGetNeighbor(
+ FirstChildElement,
+ NextSiblingElement,
+ goUpForever,
+ )(node)
+}
+func GetNextNeighborNodeExcludingOwnChild(node *html.Node) *html.Node {
+ return UNSTABLE_initGetNeighbor(
+ skipFirstChild,
+ NextSiblingNode,
+ goUpForever,
+ )(node)
+}
+func GetNextNeighborElementExcludingOwnChild(node *html.Node) *html.Node {
+ return UNSTABLE_initGetNeighbor(
+ skipFirstChild,
+ NextSiblingElement,
+ goUpForever,
+ )(node)
+}
diff --git a/vendor/github.com/JohannesKaufmann/dom/tags.go b/vendor/github.com/JohannesKaufmann/dom/tags.go
new file mode 100644
index 00000000..28688173
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/dom/tags.go
@@ -0,0 +1,147 @@
+package dom
+
+import "golang.org/x/net/html"
+
+// In order to stay consistent with v1 of the library, this follows
+// the naming scheme of goquery.
+// E.g. "#text", "div", ...
+func NodeName(node *html.Node) string {
+ if node == nil {
+ return ""
+ }
+
+ switch node.Type {
+ case html.ErrorNode:
+ return "#error"
+ case html.TextNode:
+ return "#text"
+ case html.DocumentNode:
+ return "#document"
+ case html.CommentNode:
+ return "#comment"
+
+ case html.DoctypeNode:
+ // E.g. for `` it would be "html"
+ return node.Data
+ case html.ElementNode:
+ // E.g. "div" or "p"
+ return node.Data
+ }
+
+ return ""
+}
+
+func NameIsInlineNode(name string) bool {
+ switch name {
+ case
+ "#text",
+ "a",
+ "abbr",
+ "acronym",
+ "audio",
+ "b",
+ "bdi",
+ "bdo",
+ "big",
+ "br",
+ "button",
+ "canvas",
+ "cite",
+ "code",
+ "data",
+ "datalist",
+ "del",
+ "dfn",
+ "em",
+ "embed",
+ "i",
+ "iframe",
+ "img",
+ "input",
+ "ins",
+ "kbd",
+ "label",
+ "map",
+ "mark",
+ "meter",
+ "noscript",
+ "object",
+ "output",
+ "picture",
+ "progress",
+ "q",
+ "ruby",
+ "s",
+ "samp",
+ "script",
+ "select",
+ "slot",
+ "small",
+ "span",
+ "strong",
+ "sub",
+ "sup",
+ "svg",
+ "template",
+ "textarea",
+ "time",
+ "u",
+ "tt",
+ "var",
+ "video",
+ "wbr":
+ return true
+
+ default:
+ return false
+ }
+}
+
+func NameIsBlockNode(name string) bool {
+ switch name {
+ case
+ "address",
+ "article",
+ "aside",
+ "blockquote",
+ "details",
+ "dialog",
+ "dd",
+ "div",
+ "dl",
+ "dt",
+ "fieldset",
+ "figcaption",
+ "figure",
+ "footer",
+ "form",
+ "h1", "h2", "h3", "h4", "h5", "h6",
+ "header",
+ "hgroup",
+ "hr",
+ "li",
+ "main",
+ "nav",
+ "ol",
+ "p",
+ "pre",
+ "section",
+ "table",
+ "ul":
+
+ return true
+
+ default:
+ return false
+ }
+}
+
+func NameIsHeading(name string) bool {
+ switch name {
+ case
+ "h1", "h2", "h3", "h4", "h5", "h6":
+ return true
+ default:
+ return false
+ }
+}
diff --git a/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/.gitignore b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/.gitignore
new file mode 100644
index 00000000..9a3b10da
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/.gitignore
@@ -0,0 +1,27 @@
+
+# - - - - - General - - - - - #
+
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+.DS_Store
+
+
+
+# - - - - - Project Specific - - - - - #
+
+NOTES.md
+.tmp
+
+
+dist/
diff --git a/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/.goreleaser.yaml b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/.goreleaser.yaml
new file mode 100644
index 00000000..8ae2d86a
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/.goreleaser.yaml
@@ -0,0 +1,67 @@
+
+# The lines below are called `modelines`. See `:help modeline`
+# Feel free to remove those if you don't want/need to use them.
+# yaml-language-server: $schema=https://goreleaser.com/static/schema.json
+# vim: set ts=2 sw=2 tw=0 fo=cnqoj
+
+version: 2
+
+before:
+ hooks:
+ - go mod tidy
+
+builds:
+ - env:
+ - CGO_ENABLED=0
+ goos:
+ - linux
+ - windows
+ - darwin
+
+ # Note: We only use goreleaser for the CLI,
+ # so we have to go into the "cli" directory.
+ dir: cli/html2markdown
+ binary: html2markdown
+
+archives:
+ - format: tar.gz
+ # this name template makes the OS and Arch compatible with the results of `uname`.
+ name_template: >-
+ {{ .ProjectName }}_
+ {{- title .Os }}_
+ {{- if eq .Arch "amd64" }}x86_64
+ {{- else if eq .Arch "386" }}i386
+ {{- else }}{{ .Arch }}{{ end }}
+ {{- if .Arm }}v{{ .Arm }}{{ end }}
+ # use zip for windows archives
+ format_overrides:
+ - goos: windows
+ format: zip
+
+brews:
+ - name: html2markdown
+ repository:
+ owner: JohannesKaufmann
+ name: homebrew-tap
+ token: "{{ .Env.TAP_GITHUB_TOKEN }}"
+
+nfpms:
+ - id: default
+ package_name: html2markdown
+
+ vendor: JohannesKaufmann
+ homepage: https://github.com/JohannesKaufmann/html-to-markdown
+ maintainer: Johannes Kaufmann
+ description: |
+ Convert HTML to Markdown. Even works with entire websites.
+ license: MIT
+
+ formats:
+ - deb
+
+changelog:
+ sort: asc
+ filters:
+ exclude:
+ - "^docs:"
+ - "^test:"
diff --git a/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/ESCAPING.md b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/ESCAPING.md
new file mode 100644
index 00000000..ddcf6935
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/ESCAPING.md
@@ -0,0 +1,63 @@
+## Escaping
+
+Some characters have a special meaning in markdown. For example, the character "\*" can be used for lists, emphasis and dividers. By placing a backlash before that character (e.g. "\\\*") you can "escape" it. Then the character will render as a raw "\*" without the _"markdown meaning"_ applied.
+
+But why is "escaping" even necessary?
+
+
+```md
+Paragraph 1
+-
+Paragraph 2
+```
+
+The markdown above doesn't seem that problematic. But "Paragraph 1" (with only one hyphen below) will be recognized as a _setext heading_.
+
+```html
+Paragraph 1
+Paragraph 2
+```
+
+A well-placed backslash character would prevent that...
+
+
+```md
+Paragraph 1
+\-
+Paragraph 2
+```
+
+---
+
+How to configure escaping? Depending on the `EscapeMode` option, the markdown output is going to be different.
+
+```go
+conv := converter.NewConverter(
+ converter.WithEscapeMode("smart"), // default
+ converter.WithPlugins(
+ // ...
+ )
+)
+```
+
+Lets try it out with this HTML input:
+
+| | |
+| -------- | ----------------------------------------------------- |
+| input | `fake **bold** and real bold
` |
+| | |
+| | **With EscapeMode "smart"** |
+| output | `fake \*\*bold\*\* and real **bold**` |
+| rendered | fake \*\*bold\*\* and real **bold** |
+| | |
+| | **With EscapeMode "disabled"** |
+| output | `fake **bold** and real **bold**` |
+| rendered | fake **bold** and real **bold** |
+
+With **smart** escaping, we get some escape characters (the backlash "\\") but it renders correctly.
+
+With escaping **disabled**, the fake and real bold can't be distinguished in the markdown. That means it is both going to render as bold.
+
+---
+
+So now you know the purpose of escaping. However, if you encounter some content where the escaping breaks, you can manually disable it. But please also open an issue!
diff --git a/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/LICENSE b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/LICENSE
new file mode 100644
index 00000000..0adaa6b5
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Johannes Kaufmann
+
+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.
diff --git a/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/README.md b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/README.md
new file mode 100644
index 00000000..4518a258
--- /dev/null
+++ b/vendor/github.com/JohannesKaufmann/html-to-markdown/v2/README.md
@@ -0,0 +1,399 @@
+# html-to-markdown
+
+A robust html-to-markdown converter that transforms HTML (even entire websites) into clean, readable Markdown. It supports complex formatting, customizable options, and plugins for full control over the conversion process.
+
+Use the fully extendable [Golang library](#golang-library) or a quick [CLI command](#cli---using-it-on-the-command-line). Alternatively, try the [Online Demo](https://html-to-markdown.com) or [REST API](https://html-to-markdown.com/api) to see it in action!
+
+Here are some _cool features_:
+
+- **Bold & Italic:** Supports bold and italic—even within single words.
+
+ 
+
+- **List:** Handles ordered and unordered lists with full nesting support.
+
+ 
+
+- **Blockquote:** Blockquotes can include other elements, with seamless support for nested quotes.
+
+ 
+
+- **Inline Code & Code Block:** Correctly handles backticks and multi-line code blocks, preserving code structure.
+
+ 
+
+- **Link & Image:** Properly formats multi-line links, adding escapes for blank lines where needed.
+
+ 
+
+- **Smart Escaping:** Escapes special characters only when necessary, to avoid accidental Markdown rendering.
+ 🗒️ [ESCAPING.md](/ESCAPING.md)
+
+ 
+
+- **Remove/Keep HTML:** Choose to strip or retain specific HTML tags for ultimate control over output.
+
+ 
+
+- **Plugins:** Easily extend with plugins. Or create custom ones to enhance functionality.
+
+ 
+
+- **Table Plugin:** Converts tables with support for alignment, rowspan and colspan.
+
+ 
+
+---
+
+## Usage
+
+[💻 Golang library](#golang-library) | [📦 CLI](#cli---using-it-on-the-command-line) | [▶️ Hosted Demo](https://html-to-markdown.com) | [🌐 Hosted REST API](https://html-to-markdown.com/api)
+
+---
+
+## Golang Library
+
+### Installation
+
+```bash
+go get -u github.com/JohannesKaufmann/html-to-markdown/v2
+```
+
+_Or if you want a specific commit add the suffix `/v2@commithash`_
+
+> [!NOTE]
+> This is the documentation for the v2 library. For the old version switch to the ["v1" branch](https://github.com/JohannesKaufmann/html-to-markdown/tree/v1).
+
+### Usage
+
+[](https://pkg.go.dev/github.com/JohannesKaufmann/html-to-markdown/v2)
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ htmltomarkdown "github.com/JohannesKaufmann/html-to-markdown/v2"
+)
+
+func main() {
+ input := `Bold Text `
+
+ markdown, err := htmltomarkdown.ConvertString(input)
+ if err != nil {
+ log.Fatal(err)
+ }
+ fmt.Println(markdown)
+ // Output: **Bold Text**
+}
+```
+
+- 🧑💻 [Example code, basics](/examples/basics/main.go)
+
+Use `WithDomain` to convert _relative_ links to _absolute_ links:
+
+```go
+package main
+
+import (
+ "fmt"
+ "log"
+
+ htmltomarkdown "github.com/JohannesKaufmann/html-to-markdown/v2"
+ "github.com/JohannesKaufmann/html-to-markdown/v2/converter"
+)
+
+func main() {
+ input := `Bold Text `
+
+ conv := converter.NewConverter(
+ converter.WithPlugins(
+ base.NewBasePlugin(),
+ commonmark.NewCommonmarkPlugin(
+ commonmark.WithStrongDelimiter("__"),
+ // ...additional configurations for the plugin
+ ),
+
+ // ...additional plugins (e.g. table)
+ ),
+ )
+
+ markdown, err := conv.ConvertString(input)
+ if err != nil {
+ log.Fatal(err)
+ }
+ fmt.Println(markdown)
+ // Output: __Bold Text__
+}
+```
+
+- 🧑💻 [Example code, options](/examples/options/main.go)
+
+> [!NOTE]
+> If you use `NewConverter` directly make sure to also **register the commonmark and base plugin**.
+
+---
+
+### Collapse & Tag Type
+
+
+
+You can specify how different HTML tags should be handled during conversion.
+
+- **Tag Types:** When _collapsing_ whitespace it is useful to know if a node is _block_ or _inline_.
+ - So if you have Web Components/Custom Elements remember to register the type using `TagType` or `RendererFor`.
+ - Additionally, you can _remove_ tags completely from the output.
+- **Pre-built Renderers:** There are several pre-built renderers available. For example:
+ - `RenderAsHTML` will render the node (including children) as HTML.
+ - `RenderAsHTMLWrapper` will render the node as HTML and render the children as markdown.
+
+> [!NOTE]
+> By default, some tags are automatically removed (e.g. `