script.go.template

// vim: ft=go

// script_template.go
// This file is used as a template for inline scripts.

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"strconv"
	"strings"
)

// ---- helpers ----

// die prints err to stderr and exits 1. No-op if err is nil.
func die(err error) {
	if err != nil {
		fmt.Fprintln(os.Stderr, "error:", err)
		os.Exit(1)
	}
}

// must unwraps a (value, error) pair, calling die on error.
//
//	n, err := strconv.Atoi(s)   →   n := must(strconv.Atoi(s))
func must[T any](v T, err error) T {
	die(err)
	return v
}

// atoi parses s as an int. Exits on failure.
func atoi(s string) int { return must(strconv.Atoi(strings.TrimSpace(s))) }

// atof parses s as a float64. Exits on failure.
func atof(s string) float64 { return must(strconv.ParseFloat(strings.TrimSpace(s), 64)) }

// pp returns v formatted as indented JSON (falls back to %+v on error).
// Used with auto-print: pp(myMap) prints the JSON automatically.
func pp(v any) string {
	b, err := json.MarshalIndent(v, "", "  ")
	if err != nil {
		return fmt.Sprintf("%+v", v)
	}
	return string(b)
}

// trim returns strings.TrimSpace(s).
func trim(s string) string { return strings.TrimSpace(s) }

// splitlines splits a multi-line string into a slice, dropping the trailing newline.
func splitlines(s string) []string { return strings.Split(strings.TrimRight(s, "\n"), "\n") }

var _reCache sync.Map

func _reCached(pat string) *regexp.Regexp {
	if v, ok := _reCache.Load(pat); ok {
		return v.(*regexp.Regexp)
	}
	r := regexp.MustCompile(pat)
	_reCache.Store(pat, r)
	return r
}

// match returns submatches: [0]=full match, [1+]=capture groups. nil if no match.
func match(pat, s string) []string { return _reCached(pat).FindStringSubmatch(s) }

// named returns named capture groups as a map. nil if no match.
func named(pat, s string) map[string]string {
	r := _reCached(pat)
	m := r.FindStringSubmatch(s)
	if m == nil {
		return nil
	}
	result := map[string]string{}
	for i, name := range r.SubexpNames() {
		if name != "" && i < len(m) {
			result[name] = m[i]
		}
	}
	return result
}

// ---- end helpers ----

func main() {
	// {{INLINE_BODY}}
}