### HastyScribe Command-line Usage Example

Source: https://context7.com/h3rald/hastyscribe/llms.txt

An example command line invocation to build the document with different parameters

```bash
hastyscribe api-docs.md 
  --field/product="MyApp API" 
  --field/email="api-support@example.com" 
  --user-css=api-theme.css 
  --watermark=company-logo.svg
```

--------------------------------

### Markdown API Documentation Example

Source: https://context7.com/h3rald/hastyscribe/llms.txt

A full-featured example of API documentation written in Markdown, showcasing various HastyScribe features.

```Markdown
% API Documentation
% Engineering Team
% - 

{{api-base -> https://api.example.com}}
{{version -> v2.1.0}}

{#endpoint ->
### $1

**Method**: `$2`
**URL**: `{{api-base}}$3`

$4
#} 

# REST API Reference {{version}} 

**Last Updated**: {{$full-date}} 

## Overview

This document describes the {{product}} REST API {{version}}.
For support, contact {{email}}.

> %note%
> **Authentication Required**

> All endpoints require a valid Bearer token in the Authorization header.

## Authentication

{#endpoint||Authenticate||POST||/auth/login||Authenticate user and receive access token.

**Request Body**:
```json
{
  "username": "user@example.com",
  "password": "secret123"
}
```

**Response**: [200](class:badge-success)
```json
{
  "token": "eyJhbGciOiJ...",
  "expires": 3600
}
```
#}

## User Management

{@ api-users.md || 2 @}

## Status Codes

| Code |
Status |
Description |
|-----:|:-------|:------------|
| 200  |
[OK](class:badge-success) | Request succeeded |
| 201  |
[Created](class:badge-success) | Resource created |
| 400  |
[Bad Request](class:badge-danger) | Invalid parameters |
| 401  |
[Unauthorized](class:badge-danger) | Authentication failed |
| 404  |
[Not Found](class:badge-warning) | Resource not found |

> %warning%
> **Rate Limiting**

> API requests are limited to 1000 calls per hour per IP address.

---

{{signature ->
**Questions?**
Email: {{email}}
Docs: https://docs.example.com
}}

{{signature}}
```

--------------------------------

### Makefile Integration

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Example Makefile demonstrating how to integrate HastyScribe into a build workflow.

```Makefile
.PHONY: docs
docs:
	@echo "Building documentation..."
	@hastyscribe --output-dir=dist/docs 
		--field/product="MyApp API" 
		--field/email="api-support@example.com" 
		--user-css=api-theme.css 
		--watermark=company-logo.svg
	@echo "Documentation built successfully"
```

--------------------------------

### Package.json Script Integration

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Example script in `package.json` to build and watch for changes in documentation files.

```JSON
{
  "scripts": {
    "docs": "hastyscribe README.md --output-file=docs/index.htm",
    "docs:all": "hastyscribe --output-dir=build/docs docs/*.md",
    "docs:watch": "watch 'npm run docs' docs/"
  }
}
```

--------------------------------

### Compile Markdown files using HastyScribe CLI

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Demonstrates basic command-line usage to compile single or multiple Markdown files into HTML, specifying output destinations and handling overwrites. Requires the HastyScribe executable to be installed and accessible in the system PATH.

```bash
# Compile single file to HTML
hastyscribe document.md
# Output: document.htm

# Compile multiple files using glob patterns
hastyscribe *.md docs/**/*.md

# Compile to specific output file
hastyscribe input.md --output-file=custom-name.html

# Output to stdout for piping
hastyscribe document.md --output-file=- | grep "section"

# Compile to directory (all outputs go to flat structure)
hastyscribe --output-dir=build *.md src/*.md

# Prevent overwriting existing files
hastyscribe --no-clobber -d=output *.md
```

--------------------------------

### Create parameterized text substitution with Macros

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Provides examples of defining macros with parameters and invoking them to generate dynamic content. Macros support multiline templates and can incorporate snippets or fields, but cannot be nested. Works within HastyScribe's markdown processing.

```markdown
{#greet -> Hello, $1! Welcome to $2.#}
{#alert -> ⚠️ **$1**: $2#}
{#link -> [$1]($2)#}
{#version-badge -> [v$1](class:badge-success) Released: $2#}

{#greet||Alice||HastyScribe#}
{#alert||Warning||System will restart in 5 minutes#}
{#link||Documentation||https://docs.example.com#}
{#version-badge||2.1.0||January 2025#}

{#api-endpoint ->
## $1

**Method**: `$2`
**URL**: `$3`
**Description**: $4
#}

{#api-endpoint||Get User||GET||/api/users/{id}||Retrieves user by ID#}
```

--------------------------------

### Compile Markdown files programmatically using HastyScribe Nim API

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Provides a Nim example that configures compilation options, defines custom fields, creates a HastyScribe instance, and compiles a Markdown file to a self-contained HTML document. Requires the `hastyscribe` Nim module and the `tables` module.

```nim
import hastyscribe
import tables

# Configure compilation options
var options = HastyOptions(
  toc: true,           # Generate table of contents
  embed: true,         # Embed all resources
  fragment: false,     # Generate full HTML document
  iso: false,          # Use standard date format
  minifycss: false,    # Don't minify CSS
  noclobber: true      # Don't overwrite existing files
)

# Define custom fields for substitution
var fields = initTable[string, string]()
fields["version"] = "2.1.0"
fields["author"] = "Engineering Team"
fields["product"] = "MyApp"

# Create HastyScribe instance
var hs = newHastyScribe(options, fields)

# Compile markdown file to HTML
hs.compile("documentation.md")
# Output: documentation.htm with all resources embedded
```

--------------------------------

### Formatting Code Blocks in HastyScribe with Nim Example

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax-block.md

Code blocks are indented by four spaces or fenced with ~~~ or ```; no syntax highlighting is supported to avoid JavaScript. This Nim procedure reads and encodes image files, depending on Nim's file and encoding modules. Inputs are file path and format; outputs encoded string or warning.

```nim
proc encode_image_file*(file, format): string =
  if (file.existsFile):
    let contents = file.readFile
    return encode_image(contents, format)
  else: 
    echo("Warning: image '" & file & "' not found.")
    return file
```

--------------------------------

### Creating Headings in HastyScribe Markdown

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax-block.md

Headings are created by prepending one to six hash symbols (#) to the heading text, defining levels H1 through H6. If document headers are used, the title becomes H1, so body headings should start from H2. This provides simple hierarchical structure without additional dependencies.

```markdown
# Heading 1
## Heading 2
### Heading 3
#### Heading 4
##### Heading 5
###### Heading 6
```

--------------------------------

### Define substitution macro with parameters

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax.md

Creates a reusable macro with parameter placeholders. Uses => syntax to define a macro named 'greet' with two parameters that replace $1 and $2 placeholders. Supports multiline content and preserves whitespace.

```hastyscribe
{#greet => Hello, $1! Are you $2?#}
```

--------------------------------

### GitHub Actions Workflow

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Demonstrates a GitHub Actions workflow for building and deploying HastyScribe documentation.

```YAML
name: Documentation
on: [push]
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Install HastyScribe
        run: |
          wget https://github.com/h3rald/hastyscribe/releases/download/v2.1.0/hastyscribe_v2.1.0_linux_x64.zip
          unzip hastyscribe_v2.1.0_linux_x64.zip
          chmod +x hastyscribe
      - name: Build docs
        run: ./hastyscribe docs/**/*.md --output-dir=dist
      - name: Deploy
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./dist
```

--------------------------------

### Table Syntax with Alignment (Markdown)

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Demonstrates the markdown table syntax, including basic tables, columns with specified text alignment (left, center, right), and a responsive table wrapper using the %responsive% prefix.

```markdown
<!-- Basic table -->
| Header 1 | Header 2 | Header 3 |
|----------|----------|----------|
| Cell 1   | Cell 2   | Cell 3   |
| Cell 4   | Cell 5   | Cell 6   |

<!-- Aligned columns -->
| Left Aligned | Center Aligned | Right Aligned |
|:-------------|:--------------:|--------------:|
| Left         | Center         | Right         |
| Text         | Text           | 123.45        |

<!-- Responsive table (scrollable on mobile) -->
> %responsive%
> | API Endpoint | Method | Parameters | Response | Status |
> |--------------|--------|------------|----------|--------|
> | /api/users   | GET    | page, limit | User[]  | 200    |
> | /api/users/:id | GET  | id         | User    | 200    |
> | /api/users   | POST   | name, email | User   | 201    |
> | /api/users/:id | PUT  | name, email | User   | 200    |
> | /api/users/:id | DELETE | id       | null    | 204    |
```

--------------------------------

### Styled Blockquote Sections (Markdown)

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Shows how to use blockquote syntax with specific prefixes (%note%, %warning%, %tip%, %sidebar%, %terminal%, %responsive%) to create styled notes, callouts, sidebars, terminal outputs, and responsive tables.

```markdown
<!-- Information note -->
> %note%
> **Note**: This is important information to remember.
> 
> Multiple paragraphs are supported within notes.

<!-- Warning callout -->
> %warning%
> **Warning**: Destructive operation!
> 
> This action cannot be undone.

<!-- Tip/hint box -->
> %tip%
> **Tip**: Use keyboard shortcuts for faster navigation.
> 
> Press `Ctrl+F` to search.

<!-- Sidebar content -->
> %sidebar%
> **Related Topics**
> 
> - Authentication
> - Authorization
> - API Keys

<!-- Terminal/console output -->
> %terminal%
> $ hastyscribe document.md
> Processing document.md...
> Output: document.htm

<!-- Responsive table wrapper -->
> %responsive%
> | Column 1 | Column 2 | Column 3 |
> |----------|----------|----------|
> | Data 1   | Data 2   | Data 3   |
```

--------------------------------

### Build Documentation with HastyScribe in Nim

Source: https://context7.com/h3rald/hastyscribe/llms.txt

This Nim procedure, `buildDocumentation`, leverages the HastyScribe library to compile Markdown files from a source directory to an output directory. It supports custom fields for metadata, configures HastyScribe options like ToC generation and CSS minification, and handles potential compilation errors.

```nim
import hastyscribe, tables, os, strutils

proc buildDocumentation*(srcDir, outDir: string,
                         customFields: HastyFields = initTable[string, string]()): seq[string] =
  ## Build all markdown files in srcDir to outDir
  ## Returns list of generated HTML files

  result = @[]

  # Configure options
  var options = HastyOptions(
    toc: true,
    embed: true,
    fragment: false,
    iso: true,
    minifycss: true,
    noclobber: true,
    outputToDir: true,
    output: outDir
  )

  # Initialize fields with custom values
  var fields = initTable[string, string]()
  for key, val in customFields:
    fields[key] = val

  # Create HastyScribe instance
  var hs = newHastyScribe(options, fields)

  # Process all markdown files
  for file in walkDirRec(srcDir):
    if file.endsWith(".md"):
      echo "Processing: ", file
      try:
        hs.compile(file)
        let outFile = outDir / file.extractFilename().changeFileExt("htm")
        result.add(outFile)
        echo "Generated: ", outFile
      except CatchableError as e:
        echo "Error processing ", file, ": ", e.msg

# Usage
when isMainModule:
  var fields = initTable[string, string]()
  fields["project"] = "MyProject"
  fields["version"] = "1.0.0"
  fields["author"] = "Dev Team"

  let generated = buildDocumentation("docs/", "build/", fields)
  echo "\nGenerated ", generated.len, " documents:"
  for file in generated:
    echo "  - ", file

```

--------------------------------

### Markdown Definition Lists

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Demonstrates the use of extended syntax for creating definition lists in Markdown.

```Markdown
Term 1
:   Definition of term 1

Term 2
:   First definition of term 2
:   Second definition of term 2

API Endpoint
:   A URL path that accepts HTTP requests and returns responses
:   Example: `/api/users/{id}`

Transclusion
:   The inclusion of external file content within a document
:   Syntax: `{@ file.md || offset @}`

Data URI
:   A URI scheme that embeds data directly in documents
:   Format: `data:[<mediatype>][;base64],<data>`
```

--------------------------------

### Add custom styling, scripts, and watermarks via HastyScribe CLI

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Shows how to enhance generated HTML with user-provided CSS, JavaScript, and watermark images, as well as combine multiple customizations and minify built-in CSS. The options are passed as flags to the HastyScribe executable.

```bash
# Add custom stylesheet to document
hastyscribe document.md --user-css=custom-theme.css

# Add custom JavaScript for interactivity
hastyscribe document.md --user-js=analytics.js

# Add watermark image (displayed as overlay on all pages)
hastyscribe document.md --watermark=logo.png

# Combine multiple customizations
hastyscribe report.md \
  --user-css=corporate-theme.css \
  --watermark=company-logo.svg \
  --field/company="Acme Corp" \
  --field/version="2.1.0"

# Minify built-in CSS for smaller file size
hastyscribe document.md --minify-css
```

--------------------------------

### POST /auth/login

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Authenticates a user with credentials and returns a JWT access token. Use this endpoint to obtain a token for subsequent authenticated calls.

```APIDOC
## POST /auth/login\n\n### Description\nAuthenticate user and receive an access token.\n\n### Method\nPOST\n\n### Endpoint\n/auth/login\n\n### Parameters\n#### Path Parameters\n_(none)_\n\n#### Query Parameters\n_(none)_\n\n#### Request Body\n- **username** (string) - Required - User email address\n- **password** (string) - Required - User password\n\n### Request Example\n{\n  \"username\": \"user@example.com\",\n  \"password\": \"secret123\"\n}\n\n### Response\n#### Success Response (200)\n- **token** (string) - JWT access token\n- **expires** (integer) - Expiration time in seconds\n\n### Response Example\n{\n  \"token\": \"eyJhbGciOiJ...\",\n  \"expires\": 3600\n}
```

--------------------------------

### Control output features with HastyScribe CLI options

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Illustrates usage of flags to modify table of contents generation, date formatting, fragment output, and resource embedding. These options allow tailoring of the HTML output to specific publishing needs.

```bash
# Disable automatic table of contents generation
hastyscribe document.md --notoc

# Use ISO 8601 date format in footer
hastyscribe document.md --iso

# Generate HTML fragment without full document structure
hastyscribe fragment.md --fragment

# Disable resource embedding (external references)
hastyscribe document.md --noembed

# Combine options for specific output needs
hastyscribe api-docs.md --fragment --notoc --noembed
```

--------------------------------

### Syntax-Highlighted Fenced Code Blocks (Markdown)

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Illustrates the use of fenced code blocks with language specifiers for syntax highlighting in various programming languages like Python, JavaScript, Nim, and Bash.

```markdown
```python
def compile_markdown(input_file: str) -> str:
    """Compile markdown file to HTML."""
    with open(input_file, 'r') as f:
        content = f.read()
    return markdown_to_html(content)

# Usage
result = compile_markdown('document.md')
print(f"Generated: {result}")
```

```javascript
// Fetch API data with error handling
async function fetchUsers() {
  try {
    const response = await fetch('/api/users');
    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }
    return await response.json();
  } catch (error) {
    console.error('Fetch failed:', error);
    return [];
  }
}
```

```nim
import hastyscribe, tables

proc generateDocs*(files: seq[string]): void = 
  var options = HastyOptions(toc: true, embed: true)
  var fields = initTable[string, string]()
  var hs = newHastyScribe(options, fields)

  for file in files:
    echo "Compiling: ", file
    hs.compile(file)
```

```bash
#!/bin/bash
# Build documentation from all markdown files
find docs/ -name "*.md" -exec hastyscribe {} \;

# Generate with custom styling
hastyscribe manual.md \
  --user-css=theme.css \
  --watermark=logo.png \
  --field/version="$(git describe --tags)"
```
```

--------------------------------

### Compile Markdown strings directly with HastyScribe Nim API

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Demonstrates how to compile Markdown content held a string to either a full HTML document or an HTML fragment using the Nim API, avoiding file I/O. Useful for dynamic content generation within applications.

```nim
import hastyscribe
import tables

var options = HastyOptions(toc: true, embed: true)
var fields = initTable[string, string]()
var hs = newHastyScribe(options, fields)

# Compile markdown string to full HTML document
let markdown = """
# API Reference

## Authentication
Use Bearer tokens for API access.

## Endpoints
- GET /api/users
- POST /api/users
"""

let htmlDoc = hs.compileDocument(markdown, ".")
echo htmlDoc
# Output: Complete HTML document with embedded styles and fonts

# Compile to HTML fragment (no document structure)
let htmlFragment = hs.compileFragment(markdown, ".", toc=false)
echo htmlFragment
# Output: Just the HTML content without <html>, <head>, <body> tags
```

--------------------------------

### Use substitution macro with parameters

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax.md

Invokes a previously defined macro with specific parameter values. Uses double pipe || syntax to separate macro name from parameters. Parameters are substituted in order for $1, $2, etc.

```hastyscribe
{#greet||Fabio||ready#}
```

--------------------------------

### Field substitution for built-in and custom values

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Illustrates how built-in date/time fields and user-defined fields are inserted into markdown. Custom fields are supplied via the HastyScribe CLI. The markdown block shows placeholder usage, while the Bash snippet demonstrates field definition at compile time.

```markdown
Document generated: {{$full-date}} at {{$time}}
Timestamp: {{$timestamp}}
Date: {{$date}} ({{$year}}-{{$month}}-{{$day}})
Time: {{$time-24}} ({{$timezone-offset}})
Day: {{$weekday}}, {{$month-name}} {{$short-day}}

Product: {{$product}}
Version: {{$version}}
Environment: {{$environment}}
```

```bash
hastyscribe release-notes.md \
  --field/product="MyApp" \
  --field/version="3.2.1" \
  --field/environment="Production" \
  --field/release-date="2025-01-15"

# All {{$field}} references replaced with values
```

--------------------------------

### Inserting Images in HastyScribe Markdown

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax-block.md

Images use ![alt](url =widthxheight) syntax, supporting local paths or URLs like links. Automatic HTTP downloads timeout after 5 seconds, lack proxy support, and require SSL recompilation for HTTPS. Unsuccessful downloads leave links intact.

```markdown
![HastyScribe Logo](./images/hastyscribe.png =221x65)
```

--------------------------------

### Compile Markdown File in Nim

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-api.md

This snippet compiles a Markdown file into HTML using the compile procedure. Requires a mutable HastyScribe instance and file path. Inputs are the input file path; no direct output string, as it's side-effect based. Focused on file-based input; assumes file exists and is readable.

```nim
proc compile*(hs: var HastyScribe, input_file: string)
```

--------------------------------

### Creating Tables in HastyScribe Markdown

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax-block.md

Tables use pipe (|) separated columns and dash (-) lines for headers, following PHP Markdown Extra syntax. Multi-row cells are unsupported; complex tables require HTML. Inputs are plain text rows; outputs rendered HTML tables, optionally responsive when wrapped in responsive blocks.

```markdown
Column Header 1 | Column Header 2 | Column Header 3 
----------------|-----------------|----------------
Cell 1,1        | Cell 1,2        | Cell 1, 3
Cell 2,1        | Cell 2,2        | Cell 2, 3
Cell 3,1        | Cell 3,2        | Cell 3, 3
```

--------------------------------

### Apply CSS Classes to Inline Elements (Markdown)

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Demonstrates using markdown syntax with inline CSS classes for visual elements like status badges, platform badges, language badges, and FontAwesome icons. It also shows how to combine badges with icons.

```markdown
<!-- Status badges -->
[TODO](class:badge-todo) [FIXME](class:badge-fixme)
[DONE](class:badge-success) [WIP](class:badge-warning)
[DEPRECATED](class:badge-danger)

<!-- Priority badges -->
[P0](class:badge-critical) [P1](class:badge-urgent)
[P2](class:badge-important) [P3](class:badge-normal)

<!-- Platform badges -->
[Linux](class:badge-linux) [Windows](class:badge-windows)
[macOS](class:badge-macos) [Android](class:badge-android)
[iOS](class:badge-ios)

<!-- Language badges -->
[Python](class:badge-python) [JavaScript](class:badge-js)
[Rust](class:badge-rust) [Go](class:badge-go)
[Java](class:badge-java) [C++](class:badge-cpp)

<!-- FontAwesome icons -->
[icon](class:fa-star) [icon](class:fa-heart) [icon](class:fa-check)
[icon](class:fa-times) [icon](class:fa-warning) [icon](class:fa-info)
[icon](class:fa-gear) [icon](class:fa-download) [icon](class:fa-upload)
[icon](class:fa-user) [icon](class:fa-lock) [icon](class:fa-key)

<!-- Combined badge with icon -->
[icon](class:fa-bug) [Bug #1234](class:badge-bug)
[icon](class:fa-check-circle) [Test Passed](class:badge-success)
```

--------------------------------

### Compile Markdown Fragment in Nim

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-api.md

This snippet compiles Markdown input into an HTML fragment without embedding styles. It requires a mutable HastyScribe instance and uses the compileFragment procedure. Inputs are Markdown string and directory path; output is HTML string. TOC option is optional; focuses on fragments, not full documents.

```nim
proc compileFragment*(hs: var HastyScribe, input, dir: string, toc = false): string {.discardable.}
```

--------------------------------

### Include external markdown files using Content Transclusion

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Demonstrates how to embed other markdown files into a main document with optional heading level offsets. No additional dependencies are required beyond HastyScribe's processing engine. The transclusion adjusts heading levels based on the provided offset.

```markdown
# Product Documentation

{@ installation.md || 0 @}

{@ configuration.md || 1 @}

{@ api-reference.md || 1 @}

{@ troubleshooting.md || 0 @}

<!-- installation.md -->
## System Requirements
### Hardware
### Software

<!-- When transcluded with offset 1, becomes: -->
### System Requirements
#### Hardware
#### Software
```

--------------------------------

### Footnote Syntax (Markdown)

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Shows the standard markdown syntax for creating and referencing footnotes. This feature allows for adding supplementary information without cluttering the main text.

```markdown
Here is some text with a footnote[^1].

And here is another footnote[^note].

[^1]: This is the first footnote.
[^note]: This is another footnote with different text.
```

--------------------------------

### Instantiate HastyScribe Object in Nim

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-api.md

This snippet instantiates a new HastyScribe object using the newHastyScribe procedure. It depends on having HastyOptions and HastyFields defined. Inputs are HastyOptions and HastyFields objects; output is a HastyScribe instance. Limited to custom options and fields; does not handle defaults or validation.

```nim
proc newHastyScribe*(options: HastyOptions, fields: HastyFields): HastyScribe
```

--------------------------------

### Compile Markdown Document in Nim

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-api.md

This snippet compiles Markdown into a self-contained HTML document with embedded styles. Depends on a mutable HastyScribe object via compileDocument. Inputs are Markdown string and directory for transclusions; output is full HTML. No TOC or fragment options; limited to complete documents.

```nim
proc compileDocument*(hs: var HastyScribe, input, dir: string): string {.discardable.}
```

--------------------------------

### Using HTML Details Element in HastyScribe

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax-block.md

The <details> tag creates collapsible content visible only when toggled via <summary>. Embed directly in Markdown for interactive disclosures. No dependencies; inputs HTML structure, outputs browser-rendered widget with no limitations in supported browsers.

```html
<details>
<summary>Details</summary>
The `details` element can be used to create a disclosure element whose contents are only visible when the element is toggled open.
</details>
```

--------------------------------

### Define HastyScribe Types in Nim

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-api.md

This snippet defines the Nim types used in HastyScribe, including objects for options and tables for fields, styles, and macros. It requires the HastyScribe library to be imported in a Nim program. Inputs are none; outputs are type definitions for use in compilation. No specific limitations mentioned, but types must be used within the Nim language context.

```nim
HastyOptions* = object
     toc*: bool
     input*: string
     output*: string
     css*: string
     js*: string
     watermark*: string
     fragment*: bool
     embed*: bool

HastyFields* = Table[string, string]
HastySnippets* = Table[string, string]
HastyMacros* = Table[string, string]
HastyLinkStyles* = Table[string, string]
HastyIconStyles* = Table[string, string]
HastyNoteStyles* = Table[string, string]
HastyBadgeStyles* = Table[string, string]

HastyScribe* = object
     options: HastyOptions
     fields: HastyFields
     snippets: HastySnippets
     macros: HastyMacros
     document: string
     linkStyles: HastyLinkStyles
     iconStyles: HastyIconStyles
     noteStyles: HastyNoteStyles
     badgeStyles: HastyBadgeStyles
```

--------------------------------

### Creating Block Quotes in HastyScribe Markdown

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax-block.md

Block quotes form by prepending > to each line, with nesting via additional > symbols. This indents quoted content for emphasis. No dependencies beyond standard Markdown parsing; inputs are text lines, outputs styled blockquote HTML.

```markdown
> This is a block quote.
> > This is a nested quote. 
```

--------------------------------

### Define and use reusable text blocks with Snippets

Source: https://context7.com/h3rald/hastyscribe/llms.txt

Shows how to declare snippet variables and expand them throughout a markdown document. Snippets can be single-line or multiline and may include other snippets. This feature worksatively in HastyScribe without extra tools.

```markdown
{{company -> Acme Corporation}}
{{email -> support@acme.com}}
{{product -> HastyScribe Premium}}
{{disclaimer -> This software is provided "as is" without warranty.}}

# Welcome to {{product}}

For support, contact {{company}} at {{email}}.

## License

{{disclaimer}}

{{terms => By using {{product}}, you agree to {{company}} terms.}}

{{signature ->
---
Best regards,
{{company}} Team
{{email}}
}}
```

--------------------------------

### Adding Footnotes in HastyScribe Markdown

Source: https://github.com/h3rald/hastyscribe/blob/master/doc/-syntax-block.md

Footnotes reference with [^id] in text and define with [^id]: explanation below. This generates superscript links to notes. Supports standard Markdown parsing; inputs inline markers, outputs HTML anchors with no specified limitations.

```markdown
This is some text[^1]

[^1]: This is a footnote!
```

--------------------------------

### Nim Programming Language

Source: https://context7.com/h3rald/hastyscribe/llms.txt

HastyScribe is written in Nim, a statically-typed systems programming language. This snippet highlights Nim's features and performance.

```Nim
const path = "C:\\Users\\file";

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.