docuindex

DocuIndex

A pure Go package for parsing PDF and DOCX files and extracting structured content optimized for AI search and RAG (Retrieval-Augmented Generation) applications.

** This package is under very active development. Expect frequent updates and improvements. Not yet stable. **

Features

• Pure Go - No CGO or external dependencies
• PDF Parsing - Complete PDF parser with PostScript content stream interpreter
• DOCX Parsing - Full DOCX support via ZIP/XML parsing with style resolution
• Custom Data Sources - Index arbitrary structured data with tag-based filtering
• Text Extraction - Extract text with positioning, font info, and semantic structure
• Image Extraction - Extract embedded images (JPEG, PNG, GIF, BMP, TIFF)
• Semantic Analysis - Automatic heading detection, section tracking, keyword extraction
• SQLite Storage - Unified SQLite database for all metadata and search indices
• Hybrid Search - BM25 keyword search + vector semantic search with RRF fusion
• Embedding Providers - Azure OpenAI, OpenAI, and Ollama support
• Thread-Safe - Safe for concurrent use

Installation

go get github.com/mmalcek/docuIndex

Quick Start

package main

import (
    "fmt"
    "log"

    "github.com/mmalcek/docuIndex"
)

func main() {
    // Create a store (documents will be saved to ./data directory)
    store, err := docuindex.NewStore("./data")
    if err != nil {
        log.Fatal(err)
    }
    defer store.Close()

    // Index a PDF or DOCX file
    doc, err := store.IndexDocument("./document.pdf")   // PDF
    // doc, err := store.IndexDocument("./document.docx") // DOCX
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Indexed document: %s (%d pages)\n", doc.Info.Name, doc.Info.PageCount)

    // Search across all documents
    results, err := store.Search("search query")
    if err != nil {
        log.Fatal(err)
    }

    for _, r := range results.Results {
        fmt.Printf("Found in %s (page %d): %s\n", r.DocumentName, r.Page, r.Snippet)
    }
}

API Reference

Store Operations

Create a Store

// Basic store
store, err := docuindex.NewStore("./data")

// With options
store, err := docuindex.NewStore("./data",
    docuindex.WithImageExtraction(true),    // Extract images from PDFs
    docuindex.WithChecksum(true),           // Compute SHA-256 checksums
    docuindex.WithSemanticAnalysis(true),   // Enable heading/section detection
    docuindex.WithStemming(true),           // Enable Porter stemming for search
    docuindex.WithStopWords(true),          // Filter common stop words
)

Configure Embedding Provider (Optional)

import "github.com/mmalcek/docuIndex/embedding"

// Azure OpenAI with API key (defaults to API version 2024-10-21)
provider, err := embedding.NewProvider(embedding.Config{
    Provider:   "azure",
    Endpoint:   os.Getenv("AZURE_ENDPOINT"),
    APIKey:     os.Getenv("AZURE_API_KEY"),
    Model:      "text-embedding-3-small",
    // APIVersion: "v1",           // Optional: use new v1 API format
    // APIVersion: "2024-10-21",   // Optional: explicit version (default)
})

// Azure OpenAI with Azure Identity (Managed Identity, DefaultAzureCredential, etc.)
// Optional: requires github.com/Azure/azure-sdk-for-go/sdk/azidentity
import "github.com/Azure/azure-sdk-for-go/sdk/azidentity"

cred, err := azidentity.NewDefaultAzureCredential(nil)
provider, err := embedding.NewProvider(embedding.Config{
    Provider:        "azure",
    Endpoint:        os.Getenv("AZURE_ENDPOINT"),
    Model:           "text-embedding-3-small",
    TokenCredential: cred,  // Uses Bearer token instead of api-key header
})
// Tokens are cached and automatically refreshed before expiry

// OpenAI
provider, err := embedding.NewProvider(embedding.Config{
    Provider: "openai",
    APIKey:   os.Getenv("OPENAI_API_KEY"),
    Model:    "text-embedding-3-small",
})

// Ollama (local)
provider, err := embedding.NewProvider(embedding.Config{
    Provider: "ollama",
    Endpoint: "http://localhost:11434",
    Model:    "nomic-embed-text",
})

// Add to store for semantic search
store.SetEmbeddingProvider(provider)

Index Documents

// Index from file path (PDF or DOCX)
doc, err := store.IndexDocument("./document.pdf")
doc, err := store.IndexDocument("./document.docx")

// Index from io.Reader
file, _ := os.Open("document.pdf")
doc, err := store.IndexReader(file, "document.pdf")

file, _ := os.Open("document.docx")
doc, err := store.IndexReader(file, "document.docx")

// With custom name
doc, err := store.IndexDocument("./document.pdf",
    docuindex.WithName("My Custom Name"),
)

// With custom source and tags for filtering
doc, err := store.IndexDocument("./document.pdf",
    docuindex.WithIndexSource("knowledgebase"),
    docuindex.WithIndexTags(map[string]string{
        "department": "engineering",
        "project":    "alpha",
    }),
)
// Now searchable with:
// store.Search("query", docuindex.WithSources("knowledgebase"))
// store.Search("query", docuindex.WithTags(map[string]string{"department": "engineering"}))

// With deferred embedding (for bulk imports - embed later with EmbedPendingDocuments)
doc, err := store.IndexDocument("./document.pdf",
    docuindex.WithDeferEmbedding(true),
)

Index Custom Data

// Index structured data from any source (creates new document each time)
doc, err := store.IndexCustomData(&docuindex.CustomData{
    Source:      "crm-api",
    Name:        "Customer Notes Q4 2024",
    Description: "Extracted customer interaction notes",
    Tags: map[string]string{
        "quarter": "Q4-2024",
        "type":    "customer-notes",
    },
    ImportedAt: time.Now(), // Optional: track import time for incremental updates
    Entries: []docuindex.DataEntry{
        {Content: "Meeting with Acme Corp about renewal..."},
        {Content: "Support ticket #1234: User reported issue..."},
        {Content: "Sales call summary: Interested in enterprise plan..."},
    },
})

// Index custom data with images
doc, err := store.IndexCustomData(&docuindex.CustomData{
    Source: "products",
    Name:   "Product Catalog",
    Entries: []docuindex.DataEntry{
        {
            ID:      "laptop-001",
            Content: "MacBook Pro 16-inch with M3 chip, 36GB RAM",
            Images: []docuindex.CustomImage{
                {
                    Data:        jpegBytes,           // Image bytes (required)
                    Format:      "jpeg",              // "png", "jpeg", "gif", "bmp" (required)
                    Description: "Front view",       // AI-friendly alt text (optional)
                    OriginalName: "macbook.jpg",     // Display name (optional)
                    // Width/Height auto-detected if not provided
                },
            },
        },
    },
    // Document-level images (not tied to specific entry)
    Images: []docuindex.CustomImage{
        {Data: logoPng, Format: "png", Description: "Company logo"},
    },
})

// Upsert custom data (update existing document if source + external_id match)
// On update, existing images are automatically replaced
doc, err := store.UpsertCustomData(&docuindex.CustomData{
    Source:      "salesforce-api",
    Name:        "Salesforce Opportunities",
    ExternalID:  "opportunities-q4",  // Optional - enables update-or-create behavior
    ImportedAt:  time.Now(),
    Entries: []docuindex.DataEntry{
        {Content: "Acme Corp - $50k deal in progress..."},
        {Content: "Widget Inc - Renewal pending..."},
    },
})

// Get last import time for incremental updates
lastImport, err := store.GetLastImportTime("crm-api")
if !lastImport.IsZero() {
    // Fetch only new data from source since lastImport
}

Retrieve Documents

// Get by ID
doc, err := store.GetDocument("document-id")

// Find by external system ID (e.g., Salesforce record ID)
doc, err := store.FindByExternalID("salesforce-api", "opportunities-q4")
if doc != nil {
    fmt.Printf("Found: %s\n", doc.Info.Name)
}

// List all documents
docs, err := store.ListDocuments()
for _, info := range docs {
    fmt.Printf("%s: %s (%d pages)\n", info.ID, info.Name, info.PageCount)
}

// Delete a document
err := store.DeleteDocument("document-id")

Search Operations

Basic Search (BM25 Keyword Search)

results, err := store.Search("machine learning")

for _, r := range results.Results {
    fmt.Printf("Document: %s\n", r.DocumentName)
    fmt.Printf("Page: %d\n", r.Page)
    fmt.Printf("Section: %s\n", r.Section)
    fmt.Printf("Score: %.2f\n", r.Score)
    fmt.Printf("Snippet: %s\n", r.Snippet)
}

// Search with images included in results
results, err = store.Search("diagram",
    docuindex.WithImages(true),
)
for _, r := range results.Results {
    if len(r.Images) > 0 {
        fmt.Printf("Images in section: %v\n", r.Images)
        // e.g., ["images/uuid1.png", "images/uuid2.jpeg"]
    }
}

Search Modes

// Hybrid search (BM25 + vectors with RRF fusion) - default
// Falls back to keyword-only if no embedding provider is configured
results, err := store.Search("climate change impacts",
    docuindex.WithVectorWeight(0.6),   // Weight for semantic results
    docuindex.WithKeywordWeight(0.4),  // Weight for keyword results
)

// Keyword search (BM25 only)
results, err := store.Search("neural networks",
    docuindex.WithSearchMode(docuindex.SearchModeKeyword),
)

// Semantic search (vector embeddings only) - requires embedding provider
results, err := store.Search("how does machine learning work",
    docuindex.WithSearchMode(docuindex.SearchModeSemantic),
)

Search with Options

results, err := store.Search("neural networks",
    docuindex.WithMaxResults(10),           // Limit results
    docuindex.WithMinScore(0.5),            // Minimum relevance score
    docuindex.WithContextWindow(3),         // Include 3 blocks before/after
    docuindex.WithHighlight("<b>", "</b>"), // Highlight matches in snippet
)

Search Options Reference

Understanding Vector and Keyword Weights

The WithVectorWeight and WithKeywordWeight options control how hybrid search combines semantic (vector) and keyword (BM25) results using Reciprocal Rank Fusion (RRF).

How weights work:

• Both values should be between 0.0 and 1.0
• They control the relative importance of each search signal
• The weights don't need to sum to 1.0, but typically do for clarity

Practical examples:

// Balanced hybrid search (default behavior)
results, err := store.Search("machine learning concepts",
    docuindex.WithVectorWeight(0.5),
    docuindex.WithKeywordWeight(0.5),
)

// Emphasize semantic understanding - good for conceptual queries
// "How does photosynthesis work?" benefits from semantic search
results, err := store.Search("how does photosynthesis work",
    docuindex.WithVectorWeight(0.7),
    docuindex.WithKeywordWeight(0.3),
)

// Emphasize keyword matching - good for specific terms/names
// Searching for "RFC 7231" or "John Smith" benefits from keyword search
results, err := store.Search("RFC 7231",
    docuindex.WithVectorWeight(0.3),
    docuindex.WithKeywordWeight(0.7),
)

// Pure semantic search (equivalent to SearchModeSemantic)
results, err := store.Search("explain the concept",
    docuindex.WithVectorWeight(1.0),
    docuindex.WithKeywordWeight(0.0),
)

// Pure keyword search (equivalent to SearchModeKeyword)
results, err := store.Search("exact phrase",
    docuindex.WithVectorWeight(0.0),
    docuindex.WithKeywordWeight(1.0),
)

When to adjust weights:

HNSW Search Tuning with EfSearch

The WithEfSearch option controls how thoroughly the HNSW vector index is searched. Higher values improve recall (finding more relevant results) at the cost of latency.

// Fast search - good for real-time applications
results, err := store.Search("query",
    docuindex.WithEfSearch(50),
)

// Balanced - good for most use cases
results, err := store.Search("query",
    docuindex.WithEfSearch(100),
)

// High recall - good for batch processing or critical queries
results, err := store.Search("important query",
    docuindex.WithEfSearch(200),
)

EfSearch guidelines by dataset size:

Note: WithEfSearch only affects the current query. To set a default for all searches, use WithHNSWConfig when creating the store:

store, _ := docuindex.NewStore("./data",
    docuindex.WithHNSWConfig(docuindex.HNSWConfig{
        EfSearch: 100,  // Default for all queries
    }),
)

Boolean and Phrase Queries

// Boolean operators: AND, OR, NOT (or +, -)
results, err := store.Search("machine learning AND neural")
results, err := store.Search("+required -excluded optional")

// Phrase matching with quotes
results, err := store.Search(`"exact phrase match"`)

Search in Specific Document

results, err := store.SearchInDocument("doc-id", "query")

Search with Source/Tag Filtering

// Search only custom data
results, err := store.Search("renewal",
    docuindex.WithSources("customdata"))

// Search by specific source
results, err := store.Search("renewal",
    docuindex.WithSources("crm-api"))

// Search with tag filter
results, err := store.Search("renewal",
    docuindex.WithTags(map[string]string{"quarter": "Q4-2024"}))

// Search with tag negation (! prefix excludes matching values)
results, err := store.Search("bugs",
    docuindex.WithTags(map[string]string{"status": "!Closed"}))  // Not Closed

// Combined filters
results, err := store.Search("enterprise",
    docuindex.WithSources("crm-api", "faq"),
    docuindex.WithTags(map[string]string{"type": "customer-notes"}))

Search with Metadata

Include document metadata (tags, source, external ID) in search results:

// Search with metadata included
results, err := store.Search("query", docuindex.WithMetadata(true))

for _, r := range results.Results {
    fmt.Printf("Document: %s\n", r.DocumentName)
    fmt.Printf("  Source: %s\n", r.Source)           // e.g., "crm-api"
    fmt.Printf("  ExternalID: %s\n", r.ExternalID)   // e.g., "salesforce-123"
    fmt.Printf("  Tags: %v\n", r.Tags)               // e.g., {"status": "Open", "priority": "High"}
}

// Combine with tag negation for filtering
results, err := store.Search("bugs",
    docuindex.WithTags(map[string]string{"status": "!Closed"}),
    docuindex.WithMetadata(true),  // Include metadata in results
)

Note: WithMetadata is disabled by default for performance. Enable it when you need to access tags, source, or external ID from search results.

Search with Diversification

When a single document contains many matching blocks, diversification limits results per document to improve variety:

// Limit to max 3 results per document
results, err := store.Search("machine learning",
    docuindex.WithDiversify(3),
)

Search Diagnostics

Enable diagnostics to understand search performance and behavior:

results, err := store.Search("query",
    docuindex.WithDiagnostics(true),
)

if results.Diagnostics != nil {
    fmt.Printf("Keyword results: %d\n", results.Diagnostics.KeywordResults)
    fmt.Printf("Vector results: %d\n", results.Diagnostics.VectorResults)
    fmt.Printf("Filtered by MinScore: %d\n", results.Diagnostics.FilteredByScore)
    fmt.Printf("Diversified from: %d results\n", results.Diagnostics.DiversifiedFrom)
    fmt.Printf("Timing - Keyword: %v, Vector: %v, Fusion: %v\n",
        results.Diagnostics.KeywordTime,
        results.Diagnostics.VectorTime,
        results.Diagnostics.FusionTime)
}

Get Context for RAG

// Get surrounding content blocks for a specific block
ctx, err := store.GetContext("doc-id", "blk_042", 5)

// ctx.Before - blocks before the target
// ctx.Center - the target block
// ctx.After - blocks after the target

Document Structure

Content Block

type ContentBlock struct {
    ID       string       // Unique block ID (e.g., "blk_001")
    Type     BlockType    // text, heading, image, list, table
    Content  string       // Text content or image path
    Page     int          // 1-indexed page number
    BBox     BoundingBox  // Position on page
    Font     *FontInfo    // Font metadata
    Semantic SemanticInfo // Heading level, section, keywords
}

Working with Blocks

doc, _ := store.GetDocument("doc-id")

// Get all text blocks
textBlocks := doc.GetTextBlocks()

// Get all image blocks
imageBlocks := doc.GetImageBlocks()

// Get blocks from a specific page
page3Blocks := doc.GetBlocksByPage(3)

// Find a specific block
block := doc.GetBlockByID("blk_042")

// Get images by document with optional filters
images, err := store.GetImagesByDocumentFiltered("doc-id", "", 0) // All images
images, err := store.GetImagesByDocumentFiltered("doc-id", "Introduction", 0) // By section
images, err := store.GetImagesByDocumentFiltered("doc-id", "", 3) // By page

// Get image info with AI-friendly description
info, err := store.GetImageInfo("image-uuid")
fmt.Printf("Image: %s - %s\n", info.OriginalName, info.Description)
// e.g., "macbook.jpg - Front view of MacBook Pro 16-inch"

Store Statistics

stats := store.Stats()
fmt.Printf("Documents: %d\n", stats.DocumentCount)
fmt.Printf("Total blocks: %d\n", stats.TotalBlocks)
fmt.Printf("Total images: %d\n", stats.TotalImages)
fmt.Printf("Index terms: %d\n", stats.IndexTerms)
fmt.Printf("Vectors: %d\n", stats.VectorCount)

Embedding Status

Check whether embeddings have been generated for a document:

// Quick check if any embeddings exist
hasEmb, err := store.HasEmbeddings(docID)
if hasEmb {
    fmt.Println("Document has embeddings")
}

// Get detailed embedding status
status, err := store.GetEmbeddingStatus(docID)
fmt.Printf("Progress: %.1f%% (%d/%d blocks)\n",
    status.Progress(), status.EmbeddedCount, status.TotalEmbeddable)

if status.IsComplete {
    fmt.Println("Fully embedded")
} else if status.HasEmbeddings {
    fmt.Println("Partially embedded")
} else {
    fmt.Println("No embeddings")
}

// EmbeddingStatus fields:
// - HasEmbeddings   bool      - true if any embeddings exist
// - IsComplete      bool      - true if all embeddable blocks have vectors
// - EmbeddedCount   int       - number of blocks with embeddings
// - TotalEmbeddable int       - number of blocks that can be embedded
// - Model           string    - embedding model used
// - Dimension       int       - vector dimension
// - LastUpdated     time.Time - when embeddings were last updated

Database Info

Get information about the database schema and library version (useful for debugging):

info, err := store.DatabaseInfo()
fmt.Printf("Schema version: %d\n", info.SchemaVersion)
fmt.Printf("Library version: %s\n", info.LibraryVersion)
fmt.Printf("Created: %s\n", info.CreatedAt)
fmt.Printf("Last migration: %s\n", info.LastMigration)

// DatabaseInfo fields:
// - SchemaVersion  int       - current database schema version
// - LibraryVersion string    - library version that created/migrated the DB
// - CreatedAt      time.Time - when database was first created
// - LastMigration  time.Time - when last schema migration was applied

Recommended Design Patterns

Bulk Import (Large Datasets)

For importing more than 1000 records, use batch mode with deferred embedding:

// Configure store for bulk import
store, _ := docuindex.NewStore("./data",
    docuindex.WithHNSWConfig(docuindex.HNSWConfig{
        EfConst: 64, // Faster construction for bulk import
    }),
)

// Prepare data
var allData []*docuindex.CustomData
for _, record := range records {
    allData = append(allData, &docuindex.CustomData{
        Source:     "my-source",
        ExternalID: record.ID,
        Name:       record.Title,
        Entries:    []docuindex.DataEntry{{Content: record.Content}},
    })
}

// Batch index with deferred embedding
docs, err := store.IndexCustomDataBatch(allData,
    docuindex.WithDeferEmbedding(true),
)

// Generate embeddings after all documents indexed
err = store.EmbedPendingDocuments()

Incremental Sync

For ongoing synchronization from external sources:

// Get last sync timestamp
lastImport, _ := store.GetLastImportTime("my-source")

// Fetch only changed records
changedRecords := fetchRecordsModifiedSince(lastImport)

// Index in batches with deferred embedding
const batchSize = 100
for i := 0; i < len(changedRecords); i += batchSize {
    batch := changedRecords[i:min(i+batchSize, len(changedRecords))]

    for _, record := range batch {
        store.UpsertCustomData(&docuindex.CustomData{
            Source:     "my-source",
            ExternalID: record.ID,
            Name:       record.Title,
            ImportedAt: time.Now(),
            Entries:    []docuindex.DataEntry{{Content: record.Content}},
        },
            docuindex.WithDeferEmbedding(true),
        )
    }
}

// Process embeddings (resumable if interrupted)
err = store.EmbedPendingDocuments()

Resumable Embedding Maintenance

For background processing that survives restarts:

// Find documents without embeddings (scheduled task / startup)
pending, _ := store.GetDocumentsWithoutEmbeddings()
if len(pending) > 0 {
    log.Printf("Processing %d pending documents", len(pending))
    err := store.EmbedPendingDocuments()
}

Background Embedding

For non-blocking embedding that allows your application to remain responsive:

// Start background embedding (returns immediately)
err := store.EmbedPendingDocumentsAsync()
if err != nil {
    log.Fatal(err)
}

// Check progress periodically
for store.IsBackgroundRunning() {
    status := store.GetBackgroundStatus()
    fmt.Printf("Progress: %.1f%% (%d/%d documents)\n",
        status.Progress(),
        status.DocumentsDone,
        status.DocumentsTotal)
    time.Sleep(time.Second)
}

// Or block until completion
if err := store.WaitForBackground(); err != nil {
    log.Printf("Background embedding failed: %v", err)
}

// Cancel if needed (e.g., on application shutdown)
store.CancelBackground()

The BackgroundEmbeddingStatus provides detailed progress:

• Running - whether embedding is in progress
• DocumentsTotal / DocumentsDone - progress counters
• CurrentDocID / CurrentDocName - currently processing document
• ElapsedTime - time since start
• Error - error if failed
• Progress() - completion percentage (0-100)

HNSW Tuning by Use Case

// Store-wide configuration (applied to all searches)
store, _ := docuindex.NewStore("./data",
    docuindex.WithHNSWConfig(docuindex.HNSWConfig{
        M:        16,   // Max connections (default)
        EfConst:  64,   // For bulk import
        EfSearch: 100,  // Good search quality
    }),
)

// Per-query override for recall vs latency tradeoff
results, _ := store.Search("important query",
    docuindex.WithEfSearch(200),  // Higher recall for this query
)
// Recommended: 50=fast, 100=balanced, 200+=high recall

See OPTIMISATIONS.md for detailed performance tuning guide.

Storage Architecture

DocuIndex uses a unified SQLite database for all metadata and search indices:

data/
├── docuindex.db           # SQLite database (all metadata)
├── hnsw.idx               # HNSW vector index (binary)
└── images/                # Extracted images with UUID names
    ├── a1b2c3d4-e5f6-7890-abcd-ef1234567890.png
    └── ...

Database Schema

The SQLite database contains:

• documents - Document metadata (name, path, format, page count, timestamps)
• content_blocks - Parsed content with position, font, and semantic info
• search_terms - BM25 inverted index with term positions
• document_stats - Statistics for BM25 ranking
• vectors - Block embeddings as BLOBs
• images - Image metadata with AI-friendly description (actual files in images/ folder)

Search Capabilities

BM25 Keyword Search

• Industry-standard relevance ranking
• Boolean queries (AND, OR, NOT)
• Phrase matching with position data
• Porter stemming and stop word filtering
• Heading boost (1.5x)

Semantic Vector Search

• HNSW approximate nearest neighbor
• Supports Azure OpenAI, OpenAI, Ollama
• Block-level embeddings for granular retrieval
• Cosine similarity distance

Hybrid Search

• Combines BM25 + vector results
• Reciprocal Rank Fusion (RRF) scoring
• Configurable weights

Supported PDF Features

• PDF 1.0 - 1.7
• Traditional and cross-reference stream xref tables
• Stream filters: FlateDecode, ASCIIHexDecode, ASCII85Decode, LZWDecode, RunLengthDecode
• Font types: Type1, TrueType, Type0 (CID), Type3
• Encoding support: WinAnsi, MacRoman, Standard, PDFDocEncoding
• ToUnicode CMap for proper character mapping
• Content stream operators for text positioning and graphics state
• Embedded images (DCTDecode/JPEG, PNG)

Supported DOCX Features

• Full ZIP archive parsing via standard library
• XML content parsing with namespace handling
• Style-based and font-based heading detection
• Style inheritance chain resolution
• Bullet and numbered list extraction
• Table content with row/column structure
• Inline and anchored image extraction (JPEG, PNG, GIF, BMP, TIFF)
• Dublin Core metadata (title, author, keywords)
• Application properties (page count, word count)
• Field instructions (TOC, page numbers, hyperlinks)
• Position estimation for search result context

Dependencies

• modernc.org/sqlite - Pure Go SQLite (no CGO)
• github.com/google/uuid - UUID generation
• Standard library for everything else

Limitations

• Encrypted PDFs are not supported
• JBIG2Decode and CCITTFaxDecode PDF filters have limited support
• DOCX position estimation is approximate (DOCX lacks exact positioning unlike PDF)
• DOCX vector images (EMF, WMF) are detected but skipped

License

MIT License