{"id":35003517,"url":"https://github.com/syndicatefoundation/fastrand","last_synced_at":"2026-05-23T10:02:33.283Z","repository":{"id":317706234,"uuid":"1068508432","full_name":"SyNdicateFoundation/fastrand","owner":"SyNdicateFoundation","description":"💀 A high-performance, zero-dependency Go library for generating random data. Provides fast, ergonomic alternatives to `math/rand` and `crypto/rand`, featuring a powerful, configurable templating engine for complex data generation.","archived":false,"fork":false,"pushed_at":"2025-11-13T12:47:23.000Z","size":68,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"master","last_synced_at":"2025-12-28T18:04:12.655Z","etag":null,"topics":["chacha8","csprng","fast","fastrand","generator","go","high-performance","ipv4","ipv6","pcg","performance","random","random-generator","random-numbers","random-string","randomizer","secure","template-engine","template-random","zero-dependency"],"latest_commit_sha":null,"homepage":"","language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/SyNdicateFoundation.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-10-02T13:45:46.000Z","updated_at":"2025-11-13T12:47:27.000Z","dependencies_parsed_at":null,"dependency_job_id":"17dcfd29-f482-4c4e-811a-6551ed7685a5","html_url":"https://github.com/SyNdicateFoundation/fastrand","commit_stats":null,"previous_names":["syndicatefoundation/fastrand"],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/SyNdicateFoundation/fastrand","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SyNdicateFoundation%2Ffastrand","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SyNdicateFoundation%2Ffastrand/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SyNdicateFoundation%2Ffastrand/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SyNdicateFoundation%2Ffastrand/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/SyNdicateFoundation","download_url":"https://codeload.github.com/SyNdicateFoundation/fastrand/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/SyNdicateFoundation%2Ffastrand/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33390972,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-23T04:15:53.637Z","status":"ssl_error","status_checked_at":"2026-05-23T04:15:53.242Z","response_time":53,"last_error":"SSL_read: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["chacha8","csprng","fast","fastrand","generator","go","high-performance","ipv4","ipv6","pcg","performance","random","random-generator","random-numbers","random-string","randomizer","secure","template-engine","template-random","zero-dependency"],"created_at":"2025-12-27T04:15:59.989Z","updated_at":"2026-05-23T10:02:33.277Z","avatar_url":"https://github.com/SyNdicateFoundation.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"# FastRand for Go\n\n[![Go Report Card](https://goreportcard.com/badge/github.com/SyNdicateFoundation/fastrand)](https://goreportcard.com/report/github.com/SyNdicateFoundation/fastrand)\n[![GoDoc](https://godoc.org/github.com/SyNdicateFoundation/fastrand?status.svg)](https://godoc.org/github.com/SyNdicateFoundation/fastrand)\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\n\n**FastRand** is a high-performance, zero-dependency Go library for generating random data. It provides a comprehensive suite of tools, from simple numbers to complex templated strings, with both cryptographic (ChaCha8) and non-cryptographic (PCG) sources. It is engineered to be a faster, more powerful, and more ergonomic replacement for Go's standard `math/rand` and `crypto/rand` packages for common tasks.\n\n---\n\n## Table of Contents\n\n1.  [Why FastRand? The Performance Advantage](#why-fastrand-the-performance-advantage)\n2.  [Core Features](#core-features)\n3.  [Performance Snapshot](#performance-snapshot)\n4.  [Installation](#installation)\n5.  [Core Concepts: Package vs. Engine](#core-concepts-package-vs-engine)\n6.  [**Complete API Reference**](#complete-api-reference)\n    *   [Numeric Generation](#numeric-generation)\n    *   [String \u0026 Byte Generation](#string--byte-generation)\n    *   [Slice \u0026 Map Utilities](#slice--map-utilities)\n    *   [Network \u0026 ID Generation](#network--id-generation)\n    *   [Cryptographically Secure Functions](#cryptographically-secure-functions)\n7.  [**The `Randomizer` Engine: In-Depth**](#the-randomizer-engine-in-depth)\n    *   [Placeholder Syntax](#placeholder-syntax)\n    *   [Built-in Keywords](#built-in-keywords)\n    *   [Dynamic Generation: Ranges and Choices](#dynamic-generation-ranges-and-choices)\n8.  [**The Configurable Engine: Full Customization**](#the-configurable-engine-full-customization)\n    *   [Creating a Custom Engine](#creating-a-custom-engine)\n    *   [Complete List of Engine Options](#complete-list-of-engine-options)\n9.  [Concurrency](#concurrency)\n10. [Project Information](#project-information)\n    *   [Recommended Description](#recommended-description)\n    *   [Keywords](#keywords)\n11. [License](#license)\n\n---\n\n## Why FastRand? The Performance Advantage\n\nFastRand is not just another random library; it's an intentional upgrade designed to address the performance and ergonomic limitations of Go's standard libraries for common, high-throughput use cases.\n\n#### 1. Superior PRNG Algorithm (vs. `math/rand`)\n\nThe default non-secure generator in FastRand is built on Go 1.22+'s `math/rand/v2` with a **PCG (Permuted Congruential Generator)** source.\n\n*   **Speed**: PCG is significantly faster than the legacy `math/rand` source. This allows for primitive generation (ints, floats) in **1-2 nanoseconds**.\n*   **Statistical Quality**: PCG offers better statistical properties, passing modern test suites where the old default generator would fail.\n*   **Memory Efficiency**: Core functions are engineered to be **zero-allocation**, meaning they can be called millions of times without creating any work for Go's garbage collector. This is critical for maintaining low latency in hot paths.\n\n\u003e **Result:** A generator that is faster, statistically better, and more memory-efficient than the standard library's `math/rand`.\n\n#### 2. High-Performance CSPRNG (vs. `crypto/rand`)\n\nThe secure generator is built on **ChaCha8**, a modern, high-speed stream cipher widely used in protocols like TLS 1.3.\n\n*   **In-Process Speed**: `crypto/rand` is a thin wrapper around OS-level entropy sources (e.g., `/dev/urandom`). While secure, this can involve system calls and potential lock contention under high concurrency. ChaCha8 runs entirely within your Go process, making it an extremely fast and reliable source for cryptographic needs.\n*   **Ergonomic API**: FastRand provides a rich, developer-friendly API (`SecureIntN`, `SecureString`, `SecureNumber`) that is much more convenient than manually reading from `crypto.Reader` and performing biasing calculations.\n\n\u003e **Result:** You get the security guarantees needed for cryptographic tasks with a significant performance boost and a much better developer experience.\n\n#### 3. Extreme Memory Optimization\n\nThe `Randomizer` engine is the library's most powerful feature, but it's also a performance showcase.\n\n*   **Buffer Pooling**: Instead of creating and discarding `bytes.Buffer` objects on every call, the engine uses a **`bytebufferpool`** to recycle memory. This dramatically reduces GC pressure in applications that generate many templated strings.\n*   **Allocation-Free Parsing**: The engine's internal parser is handwritten to avoid Go's standard `strings.Split` function, which allocates new slices. By manually scanning for delimiters, the engine processes templates with almost no memory overhead.\n\n\u003e **Result:** A templating engine that is not only powerful but also incredibly efficient, making it suitable for performance-critical tasks like generating mock logs, API responses, or test data at scale.\n\n## Core Features\n\n-   **Dual Random Sources**: Blazing-fast PCG for general use and secure ChaCha8 for cryptographic needs.\n-   **Configurable `Randomizer` Engine**: Create isolated engine instances with custom rules, keywords, character sets, and length constraints.\n-   **Simple \u0026 Idiomatic API**: Intuitive functions like `IntN`, `String`, and `Bytes`.\n-   **Type-Safe Generics**: Generate random numbers for any standard integer or float type with `Number[T]()`.\n-   **Rich Helper Functions**: One-line functions for `IPv4`, `IPv6`, `UUID`, `Hex`, and more.\n-   **Powerful Slice \u0026 Map Tools**: `Choice` an element, select `ChoiceMultiple` elements, `Shuffle` a slice, or pick a `ChoiceKey` from a map.\n-   **Concurrency Safe**: All functions are safe for concurrent use in goroutines.\n-   **Zero Dependencies**: Relies only on the Go standard library and the optional, high-performance `bytebufferpool`.\n\n## Performance Snapshot\n\nBenchmarks highlight the significant performance gains over standard practices.\n\n| Benchmark | Speed (`ns/op`) | Memory (`B/op`) | Allocations (`allocs/op`) |\n| :--- | :--- | :--- | :--- |\n| **`fastrand.IntN`** | `~2.4 ns/op` | `0 B/op` | `0 allocs/op` |\n| **`fastrand.SecureBytes(64)`** | `~42 ns/op` | `64 B/op` | `1 alloc/op` |\n| **`crypto/rand.Read(64)`** | `~76 ns/op` | `0 B/op` | `0 allocs/op` |\n| **`fastrand.Randomizer`** | `~1245 ns/op` | `~693 B/op` | `~13 allocs/op` |\n\nThe `Randomizer`'s result of **~13 allocations** for parsing a complex template with 5 different placeholders is exceptionally low and demonstrates the effectiveness of the memory optimizations.\n\n## Installation\n\n```sh\ngo get github.com/SyNdicateFoundation/fastrand\n```\n\n## Core Concepts: Package vs. Engine\n\nFastRand offers two modes of operation:\n\n1.  **Package-Level Functions**: For quick and common tasks, you can use functions directly from the package (e.g., `fastrand.IntN(10)`). These all use a pre-configured, shared \"default engine\" that is optimized for general use.\n\n2.  **The Configurable `Engine`**: For advanced control, you can create your own `Engine` instance (`fastrand.NewEngine(...)`). This gives you an isolated, reusable generator with its own unique set of rules, custom keywords, and output formats. This is the recommended approach for building complex, testable systems.\n\n## Complete API Reference\n\n### Numeric Generation\n\n#### `Int(min, max int) int`\nGenerates a random integer within the inclusive range `[min, max]`. Panics if `min \u003e max`.\n```go\nnum := fastrand.Int(-50, 50) // e.g., -23\n```\n*Note: Uses the fast PCG source.*\n\n#### `IntN(n int) int`\nGenerates a random integer within the half-open range `[0, n)`. Panics if `n \u003c= 0`.\n```go\nindex := fastrand.IntN(100) // e.g., 76\n```\n*Note: Uses the fast PCG source. Zero-allocation.*\n\n#### `Float64() float64`\nGenerates a random `float64` in the half-open range `[0.0, 1.0)`.\n```go\nf := fastrand.Float64() // e.g., 0.12345\n```\n*Note: Uses the fast PCG source. Zero-allocation.*\n\n#### `Bool() bool`\nReturns `true` or `false` with equal probability.\n```go\nisEnabled := fastrand.Bool() // e.g., true\n```\n\n#### `Number[T number](min, max T) T`\nA generic function to generate a random number of any standard integer or float type `T` within the inclusive range `[min, max]`.\n```go\nvar num_i16 int16 = fastrand.Number[int16](-1000, 1000)\nvar num_u32 uint32 = fastrand.Number[uint32](0, 50000)\nvar num_f32 float32 = fastrand.Number[float32](-10.5, 10.5)\n```\n\n#### `NumberN[T number](n T) T`\nA generic function to generate a random number of type `T` within the inclusive range `[0, n]`.\n```go\nval := fastrand.NumberN[int64](10000)\n```\n\n### String \u0026 Byte Generation\n\n#### `Bytes(length int) []byte`\nGenerates a slice of `length` random bytes.\n```go\ndata := fastrand.Bytes(16)\n```\n*Note: Uses the fast PCG source. Performs one allocation for the slice.*\n\n#### `Hex(length int) string`\nGenerates `length` random bytes and returns them as a 2x-length hexadecimal string.\n```go\ntoken := fastrand.Hex(8) // e.g., \"a1b2c3d4e5f6a7b8\" (16 chars)\n```\n\n#### `String(length int, charset CharsList) string`\nGenerates a random string of a given `length` using characters from the provided `charset`.\n```go\n// Pre-defined charsets:\n// CharsDigits, CharsAlphabetLower, CharsAlphabetUpper, CharsAlphabet,\n// CharsAlphabetDigits, CharsSymbolChars, CharsAll\n\npin := fastrand.String(8, fastrand.CharsDigits) // e.g., \"91827364\"\nid := fastrand.String(12, fastrand.CharsAlphabetUpper) // e.g., \"QWERTYASDFZX\"\n```\n\n### Slice \u0026 Map Utilities\n\n#### `Choice[T any](items []T) T`\nSelects and returns one random element from a slice. Panics if the slice is empty.\n```go\nnames := []string{\"Alice\", \"Bob\", \"Charlie\"}\nwinner := fastrand.Choice(names) // e.g., \"Bob\"\n```\n\n#### `ChoiceKey[T comparable, V any](items map[T]V) T`\nSelects and returns one random key from a map. Panics if the map is empty.\n```go\nscores := map[string]int{\"alpha\": 100, \"beta\": 200}\nteam := fastrand.ChoiceKey(scores) // e.g., \"beta\"\n```\n\n#### `ChoiceMultiple[T any](items []T, count int) []T`\nSelects `count` unique random elements from a slice and returns them in a new slice.\n```go\nusers := []string{\"A\", \"B\", \"C\", \"D\", \"E\"}\nwinners := fastrand.ChoiceMultiple(users, 3) // e.g., [\"D\", \"A\", \"C\"]\n```\n*Note: Uses an efficient partial shuffle algorithm.*\n\n#### `Shuffle(n int, swap func(i, j int))`\nShuffles a collection of `n` elements in place using the provided `swap` function.\n```go\nnumbers := []int{1, 2, 3, 4, 5}\nfastrand.Shuffle(len(numbers), func(i, j int) {\n\tnumbers[i], numbers[j] = numbers[j], numbers[i]\n})\n// numbers is now shuffled, e.g., [3, 1, 5, 2, 4]\n```\n\n#### `Perm(n int) []int`\nReturns a random permutation of the integers `[0, n)`.\n```go\nindices := fastrand.Perm(5) // e.g., [4, 1, 0, 3, 2]\n```\n\n### Network \u0026 ID Generation\n\n#### `IPv4() net.IP`\nGenerates a random `net.IP` representing a v4 address.\n```go\nip := fastrand.IPv4() // e.g., 198.51.100.10\n```\n\n#### `IPv6() net.IP`\nGenerates a random `net.IP` representing a v6 address.\n```go\nip := fastrand.IPv6() // e.g., 2001:db8::1234:5678\n```\n\n#### `MustFastUUID() []byte`\nGenerates a fast, non-secure v4 UUID as a 16-byte slice. Panics on error.\n```go\nuuid := fastrand.MustFastUUID()\n```\n\n### Cryptographically Secure Functions\n\nThese functions use the **ChaCha8** source and are suitable for generating passwords, keys, tokens, and other sensitive data. All `Secure*` functions that can fail return an `error`.\n\n-   **`SecureInt(min, max int) (int, error)`**: Secure integer in `[min, max]`.\n-   **`SecureBytes(length int) ([]byte, error)`**: Secure byte slice.\n-   **`SecureHex(length int) (string, error)`**: Secure hex string.\n-   **`SecureString(length int, charset CharsList) (string, error)`**: Secure string from a charset.\n-   **`SecureIPv4() (net.IP, error)`**: Secure IPv4 address.\n-   **`SecureIPv6() (net.IP, error)`**: Secure IPv6 address.\n-   **`SecureFloat64() float64`**: Secure float in `[0.0, 1.0)`.\n-   **`SecureNumber[T number](min, max T) (T, error)`**: Secure generic number.\n-   **`MustSecureUUID() []byte`**: Secure v4 UUID. Panics on error.\n\n```go\n// Example: Generate a 32-character secure password\npassword, err := fastrand.SecureString(32, fastrand.CharsAll)\nif err != nil {\n    panic(err)\n}\nfmt.Println(\"Secure Password:\", password)\n```\n\n---\n\n## The `Randomizer` Engine: In-Depth\n\nThe `Randomizer` is the library's most powerful feature, allowing you to generate complex, structured data from a single template string.\n\n### Placeholder Syntax\n\nThe engine parses a string and replaces placeholders with random data. The syntax is flexible and powerful:\n\n`{RAND[OM];[LENGTH];[TYPE]}`\n\n-   **`OM`**: The `OM` is optional. `{RAND...}` and `{RANDOM...}` are equivalent.\n-   **`[LENGTH]`**: An optional parameter that can be:\n    *   A single integer: `{RAND;10;...}`\n    *   A comma-separated list of choices: `{RAND;5,10,15;...}`\n    *   A hyphen-separated range: `{RAND;5-10;...}`\n-   **`[TYPE]`**: An optional keyword specifying the data type. Can be a single keyword or a comma-separated list of choices.\n\n### Built-in Keywords\n\n| Keyword | Description | Example Output (for length 8) |\n| :--- | :--- | :--- |\n| **`ABL`** | Alphabet, Lowercase | `abcdefgh` |\n| **`ABU`** | Alphabet, Uppercase | `ABCDEFGH` |\n| **`ABR`** | Alphabet, Random Case | `AbCdEfGh` |\n| **`DIGIT`** | Digits (`0`-`9`) | `12345678` |\n| **`HEX`** | Hexadecimal (`0`-`f`) | `a1b2c3d4e5f6a7b8` (16 chars) |\n| **`UUID`** | A v4 UUID (length ignored) | `xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx` |\n| **`IPV4`** | An IPv4 address (length ignored) | `192.0.2.1` |\n| **`IPV6`** | An IPv6 address (length ignored) | `2001:db8::...` |\n| **`EMAIL`** | A random email address | `abcdefgh@gmail.com` |\n| **`BYTES`** | Raw bytes (length respected) | `[...8 bytes...]` |\n| **`SPACE`** | Whitespace characters | ` ` |\n| **`NULL`** | Null bytes (`\\x00` - `\\x0F`) | `[...8 null bytes...]` |\n| _(default)_ | `CharsAll` if no keyword | `aB1!c@2#` |\n\n### Dynamic Generation: Ranges and Choices\n\nYou can combine these features for maximum flexibility.\n\n```go\n// Example: Generates a numeric string that is either 4, 8, or 12 characters long.\nid := fastrand.RandomizerString(\"{RAND;4,8,12;DIGIT}\")\n\n// Example: Generates a token that is 10 to 20 characters long and is either hex or uppercase.\ntoken := fastrand.RandomizerString(\"{RAND;10-20;HEX,ABU}\")\n\n// Example: Generates a contact identifier that is either a UUID or an email address.\ncontact := fastrand.RandomizerString(\"{RAND;UUID,EMAIL}\")\n```\n\n---\n\n## The Configurable Engine: Full Customization\n\nWhile the package-level functions are convenient, the real power of FastRand lies in creating and configuring your own `Engine` instances. This allows you to define isolated, reusable, and testable rule sets for data generation.\n\n### Creating a Custom Engine\n\nThe `fastrand.NewEngine(...)` function accepts a series of `Option` functions to build a custom configuration.\n\n```go\n// A comprehensive example of a custom engine.\ncustomEngine := fastrand.NewEngine(\n    // --- Length Constraints ---\n    fastrand.WithDefaultLength(20),\n    fastrand.WithMinLength(10),\n    fastrand.WithMaxLength(100),\n\n    // --- Feature Toggles ---\n    fastrand.WithRanges(false),         // Disable \"5-10\" syntax\n    fastrand.WithKeywordChoices(true),  // Keep \"HEX,UUID\" syntax enabled\n\n    // --- Encoding Rules ---\n    fastrand.WithInputEncoding(fastrand.RandomizerEncodingURL), // ONLY accept URL-encoded tags\n    fastrand.WithOutputEncoding(fastrand.RandomizerEncodingHTML), // HTML-escape literal output\n\n    // --- Keyword \u0026 Charset Customization ---\n    fastrand.WithDisabledKeywords(\"IPV6\", \"SPACE\"), // Turn off specific keywords\n    fastrand.WithCustomCharset(\"DIGIT\", []byte(\"01\")), // Make {RAND;..;DIGIT} produce binary\n    fastrand.WithCustomKeyword(\"PRODUCT_ID\", func(length int) []byte {\n        return []byte(\"PROD-\" + fastrand.String(length, fastrand.CharsAlphabetUpper))\n    }),\n)\n\n// Now, use the highly customized engine:\ntemplate := \"\u003citem pid=\\\"{RAND;12;PRODUCT_ID}\\\" code=\\\"{RAND;16;DIGIT}\\\" /\u003e\"\noutput := customEngine.RandomizerString(template)\n\n// Possible Output:\n// \u0026lt;item pid=\u0026#34;PROD-QWERASDFZXCV\u0026#34; code=\u0026#34;0110101100101101\u0026#34; /\u0026gt;\n```\n\n### Complete List of Engine Options\n\n| Option Function | Description | Default |\n| :--- | :--- | :--- |\n| `WithDefaultLength(int)` | Sets the fallback length if none is provided. | `16` |\n| `WithMinLength(int)` | Enforces a minimum length for generated data. | `1` |\n| `WithMaxLength(int)` | Enforces a maximum length for generated data. | `99` |\n| `WithRanges(bool)` | Enables/disables parsing of length ranges (`5-10`). | `true` |\n| `WithLengthChoices(bool)` | Enables/disables parsing of length choices (`5,10`). | `true` |\n| `WithKeywordChoices(bool)` | Enables/disables parsing of keyword choices (`HEX,UUID`). | `true` |\n| `WithInputEncoding(RandomizerEncoding)` | Bitmask for recognized input encodings. | `URL \\| HTML` |\n| `WithOutputEncoding(RandomizerEncoding)` | Sets encoding for literal output text. | `None` |\n| `WithDisabledKeywords(...string)` | Disables one or more built-in keywords. | (none) |\n| `WithMailProviders([]string)` | Sets a custom list of email domains. | (embedded list) |\n| `WithCustomCharset(string, []byte)` | Overrides the character set for a keyword. | (none) |\n| `WithCustomKeyword(string, func)` | Defines a new custom keyword. | (none) |\n\n---\n\n## Concurrency\n\n**This library is fully concurrency-safe.**\n\nBoth the PCG and ChaCha8 random sources provided by `math/rand/v2` are designed for safe concurrent use across multiple goroutines. You can safely call any package-level function or use an `Engine` instance from multiple goroutines without needing external locks.\n\n## License\n\nThis project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. see the [LICENSE](LICENSE) file for details.","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsyndicatefoundation%2Ffastrand","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fsyndicatefoundation%2Ffastrand","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fsyndicatefoundation%2Ffastrand/lists"}