OpenDataLoader-PDF is a production-grade, multi-language PDF-to-structured-content extraction tool designed for AI/LLM pipelines, RAG systems, and accessibility workflows. It converts PDFs into JSON, Markdown, HTML, plain text, and tagged PDF (PDF/UA) with high accuracy (0.907 overall benchmark). The core engine is written in Java (veraPDF-based) and provides a rich CLI, while Python and Node.js SDKs bundle the Java JAR and expose idiomatic APIs. A hybrid mode routes pages to an external AI backend (Docling) for OCR, formula extraction, and picture descriptions, with a triage processor deciding per-page routing based on content signals. The project also includes an MCP server for AI agent integration, a LangChain loader, and an agent skill bundle for correct usage.
GoJS is a commercial JavaScript/TypeScript diagramming library for building interactive graphs, flowcharts, org charts, and data-visualization editors in the browser. This repository is the distribution/SDK point: it ships prebuilt core bundles (release/go.js, release/go-module.js, release/go-debug.js, release/go.mjs), TypeScript declarations (release/go.d.ts), and an extensive extension kit in both classic script (extensions/) and ES-module/TypeScript (extensionsJSM/) forms. The actual core source tree is excluded (src/ is git-ignored); users consume GoJS as an npm package or script tag and build diagram templates with a fluent API backed by GraphLinksModel/TreeModel JSON data. In production the library is a model-driven rendering and editing engine: applications push node/link data into a go.Model, declarative templates and bindings map that data to Parts, and GoJS handles canvas/SVG rendering, layout, hit-testing, undo/redo, selection, and interactive tools. There are no server endpoints or standalone executables. The extension kit is intentionally sample-grade: every file warns that APIs can change in point releases and advises copying code into the consumer's project. Despite that, the extensions demonstrate sophisticated, well-structured algorithms—circle/rectangle packing, distance-transform heatmaps, quadtree spatial indexing, SCC-based swimlane routing, and table/flow layouts—and follow consistent patterns such as option-object constructors, transaction-safe mutations, and clone-protected subclasses. No test suite is present, and the same extension is duplicated across TS, ESM JS, and classic JS, creating drift risk. License is not open-source: evaluation, non-commercial, and commercial tiers are defined in the license HTML files.
Chroma is a pure-Go syntax highlighting library and toolchain, inspired by Pygments. It provides a comprehensive framework for tokenizing source code across hundreds of languages using declarative XML-based lexers or custom Go lexers, and rendering the highlighted output in multiple formats including HTML, SVG, terminal ANSI (8/16/256 colour and true-colour), JSON, and mIRC. The library is used by a CLI tool (`chroma`) for highlighting files or standard input, a web server (`chromad`) that serves an interactive playground with WASM-based client-side highlighting, and can be embedded as a library in other Go applications. Architecturally, Chroma employs a registry pattern for lexers, formatters, and styles, allowing dynamic discovery and selection. Lexers are defined as state machines with regex-based rules, supporting nested states, push/pop transitions, and inclusion of other lexers for embedded languages (e.g., PHP in HTML). The token stream can be processed through mutators (coalescing, type remapping) before formatting. Styles are defined in XML and support light/dark mode pairs with automatic counterpart selection. Key entry points include the `quick.Quick.Highlight()` convenience function, the CLI in `cmd/chroma/main.go`, the web server in `cmd/chromad/main.go`, and the WASM module in `cmd/libchromawasm/main.go`. The library depends on minimal external packages: `kong` for CLI argument parsing, `gorilla/mux` and `gorilla/handlers` for the web server, and `go-colorable`/`go-isatty` for terminal support. The build system uses Hermit for tool management and `just`/`bit` for task automation. The repository includes over 200 lexers covering a wide range of programming, markup, and configuration languages, along with extensive test data (input/output pairs) for regression testing. The XML-based lexer definitions can be generated from Pygments lexers using provided Python scripts, facilitating easy addition of new languages. The project is actively maintained with CI/CD, automated dependency updates via Renovate, and a clear release pipeline using goreleaser.
Jodit is a pure TypeScript WYSIWYG HTML editor designed for embedding in web applications. It provides a rich editing experience with a toolbar, file browser, image editor, and support for complex formatting, tables, media embedding, and source code editing. The editor is built on a modular plugin architecture with over 60 built-in plugins, a custom event system, a UI component framework, and extensive internationalization (30+ languages). It includes security-focused HTML sanitization, undo/redo with snapshot history, and async storage providers (IndexedDB, localStorage, memory). The project is MIT-licensed with a commercial PRO version offering additional plugins like AI assistant and PDF export. The architecture is layered: core modules (event emitter, DOM helpers, selection/style engine, async utilities, decorators) provide the foundation; a plugin system manages lifecycle and dependencies; UI components (buttons, forms, popups, dialogs) are built with a BEM-like naming scheme and state-driven rendering; and modules (file browser, uploader, toolbar, history) implement higher-level features. The editor can operate in inline or iframe mode, supports dark themes, and is responsive with mobile-adaptive toolbars. Key entry points are the Jodit class constructor and the static Jodit.make() factory method. The primary data flow is user input (keyboard, mouse, clipboard) processed through the selection engine and plugins, producing sanitized HTML output. External runtime dependencies are minimal (no required JavaScript libraries), but the build system relies on Webpack, TypeScript, and various development tools.
This repository is a Laravel-specific wrapper library for the core Spatie Menu package. Its primary function is to provide a fluent PHP interface for generating HTML navigation menus within Laravel applications. It extends the base menu functionality by integrating Laravel's routing system, URL generation helpers, Blade view rendering, and the Gate authorization system. The architecture follows standard Laravel package conventions, utilizing a Service Provider for IoC binding and a Facade for static access. The system operates by accepting route names, controller actions, or raw URLs as input, processing them through Laravel's routing and URL helpers, and outputting rendered HTML strings. It handles edge cases such as active state detection based on the current request URL and conditional rendering based on user permissions. The codebase is tightly coupled to the Laravel ecosystem (illuminate/* packages) but maintains a clean separation between the core menu logic (in the spatie/menu dependency) and the Laravel-specific glue code. Maintenance is evidenced by recent commits and a changelog tracking support for Laravel versions 8 through 13, indicating active adaptation to framework updates. The codebase enforces strict coding standards via PHP CS Fixer and utilizes Pest for testing, ensuring consistency and reliability. It is a high-quality utility library designed for reuse in any Laravel project requiring dynamic navigation menus.
Defuddle is a content extraction library that converts web pages into clean, readable Markdown with structured metadata (title, author, site, published date). It is the engine behind the Obsidian Web Clipper browser extension and also runs as a standalone CLI tool, an npm package, and a hosted API service on Cloudflare Workers. The architecture follows a modular pipeline: fetch HTML, detect site-specific extractors, score and select main content, remove clutter (nav, ads, sidebars), standardize complex elements (footnotes, math, code blocks, images), and convert to Markdown via Turndown. The library is designed as a more forgiving alternative to Mozilla's Readability, with support for mobile-style heuristics, schema.org metadata extraction, and extensive site-specific extractors for platforms like YouTube, Reddit, Twitter/X, ChatGPT, GitHub, and Gmail. The codebase is written in TypeScript and produces three bundles: core (browser, no extra dependencies), full (adds MathML-to-LaTeX conversion), and node (accepts any DOM implementation). The CLI uses Commander and supports file, URL, and stdin input with options for Markdown, JSON, frontmatter, and debug output. The hosted API runs on Cloudflare Workers with Stripe-based billing, rate limiting, and Durable Objects for stateful API key management. The test suite is exceptionally comprehensive, with hundreds of HTML fixtures and expected Markdown outputs covering edge cases from dozens of real-world websites, CMS patterns, and syntax highlighters. Key external dependencies include Turndown (Markdown conversion), linkedom (DOM parsing in Node.js), mathml-to-latex and Temml (math rendering), and various third-party APIs for site-specific extractors (YouTube InnerTube, FxTwitter, Reddit Atom feeds, Bilibili). The project maintains strict security practices: no innerHTML assignments outside a single utility function, URL sanitization, and XSS prevention through template-based HTML parsing. The build system uses webpack with aliases for math module switching and enforces bundle size budgets via CI scripts.
Master CSS is a comprehensive CSS framework and toolchain that enables writing CSS directly in class attributes using a concise utility syntax. The system supports multiple rendering modes: a runtime engine that dynamically generates and injects CSS in the browser, a static build-time compilation mode for zero-runtime production output, and progressive hybrid modes that pre-generate critical CSS and hydrate on the client. It includes a fully modular architecture with over 30 packages covering a core engine, compiler, scanner for class extraction, validator, language server, ESLint plugin, CLI, MCP server, and first-class integration plugins for Vite, Next.js, Nuxt, Astro, Svelte, Webpack, and more. The codebase is production-grade with extensive unit and e2e tests, a dedicated benchmarking suite measuring CSS output sizes, build timings, and browser lifecycle performance, and a documentation site with interactive playground. While primarily a JavaScript/TypeScript application library, it also contains benchmark infrastructure that produces analytical metrics. The architecture is strongly layered with well-defined schema contracts (manifest JSON) enabling loose coupling between packages.
Render is a Go library that provides a flexible rendering layer for web applications, supporting multiple output formats including JSON, XML, HTML, text, and binary data. It abstracts away the complexities of marshaling data, setting appropriate content types and headers, and executing HTML templates with support for layouts, partials, and custom template functions. The library is designed to work with any Go web framework by accepting an http.ResponseWriter. The architecture centers around a Render struct that holds configuration and compiled templates, with different renderer types (JSON, XML, HTML, etc.) implementing a common Engine interface. Notable features include automatic template recompilation in development mode, buffer pooling for efficient HTML rendering, streaming JSON output options, and a lock-free implementation by default with optional mutex locking for thread safety. The library also provides filesystem abstraction to support loading templates from disk, embedded files, or custom asset functions.
This is a PHP library that converts HTML strings to Markdown. It parses HTML into a DOMDocument, then recursively traverses the DOM tree, converting each node to its Markdown equivalent using a registry of converter classes. The architecture is clean: an `HtmlConverter` orchestrates the process, an `Environment` manages configuration and converter registration, and individual converter classes handle specific HTML elements (headers, links, lists, tables, etc.). The library supports extensive configuration options including stripping tags, preserving comments, customizing emphasis styles, and enabling table conversion. It provides both a programmatic API and a CLI binary. The code is well-structured with strict typing, interfaces, and comprehensive test coverage. It demonstrates solid software engineering practices and is actively maintained.
Snowflake is an SVG rendering library for iOS/macOS that parses SVG XML data and renders it using native CALayer and UIBezierPath. The architecture follows a modular design with separate components for document parsing, SVG element handling, style interpretation, path parsing, and utility functions. Key entry points are Document.init(data:) for parsing SVG data and SVG.view(size:) or SVG.layers(size:) for rendering. The library transforms SVG elements into shape objects that create UIBezierPath instances, which are then converted to styled CAShapeLayer objects for display. It supports inline styling, CSS-style attributes, animations, scaling, and base64-embedded images.
Nette Mail is a standalone PHP library for creating and sending emails with support for SMTP, sendmail, DKIM signing, and fallback mechanisms. It provides a clean API for composing emails with HTML/text bodies, attachments, embedded images, and automatic text alternative generation. The architecture follows a modular design with separate concerns for message creation (Message/MimePart), sending (multiple Mailer implementations), signing (DkimSigner), and HTML processing (HtmlComposer, CssInliner). The library is framework-agnostic but integrates well with Nette DI and Tracy debugging tools.
hastscript is a utility for creating Hast (HTML Abstract Syntax Tree) trees using a hyperscript-like API. It provides two main functions, `h` for HTML and `s` for SVG, which accept CSS-like selectors, properties, and children to construct virtual DOM nodes. The library is designed to be used in build tools and frameworks that work with the Hast syntax tree, such as those in the Unified collective. The core of the library is the `createH` function in `lib/create-h.js`, which is a parameterized hyperscript function that can be adapted for different domains (like HTML or SVG) by providing a schema and default tag name. Additionally, the library supports JSX via automatic and classic runtimes, implemented in `lib/create-automatic-runtime.js` and wired up in `lib/index.js`. The project is well-maintained, with recent commits and active CI workflows, and shows low technical drift with up-to-date dependencies.
Bulma is a mature, well-established CSS framework (v1.0.4) built with Sass and based on Flexbox. It provides a comprehensive set of reusable UI components, layout utilities, and responsive design tools. The codebase is organized into a modular Sass architecture with clear separation of concerns: utilities (variables, mixins, functions), base styles, elements, form controls, components, grid system, layout, and helpers. The repository includes both the core CSS framework and a Jekyll-based documentation site with Cypress end-to-end tests. A notable feature is the Bulma Customizer, a React-based application that allows real-time customization of CSS variables through an intuitive interface. The framework emphasizes zero JavaScript dependency, making it framework-agnostic and easily integrable into any project.
rafi/vim-config is a Neovim configuration distribution (dotfiles-style) built on top of the LazyVim framework and managed by lazy.nvim. It transforms vanilla Neovim into a full IDE: lazy-loaded plugins provide LSP via nvim-lspconfig + mason.nvim, completion via blink.cmp (or nvim-cmp as an extra), telescope/snacks pickers, git workflows (gitsigns, diffview, neogit, blame), treesitter syntax, and a heavily customized lualine statusline. The runtime entry point is init.lua → lua/rafi/config/lazy.lua, which bootstraps lazy.nvim, imports the LazyVim framework plus ~15 core plugin-spec modules under lua/rafi/plugins/, and layers custom options, keymaps, and autocommands on top of LazyVim defaults via targeted User autocmds. An 'extras' system (registered in lua/rafi/config/init.lua) exposes ~50 opt-in plugin specs — colorschemes, language packs, org-mode tools, UI widgets — toggleable via :LazyExtras, making the distribution both opinionated and modular for fork-and-extend use. The codebase is idiomatic Lua organized into config/, plugins/, and util/ namespaces. It makes sophisticated use of lazy.nvim's spec merging (optional = true, opts = function(_, opts) patterns), a metatable-driven util facade (lua/rafi/util/init.lua) that lazily loads submodules, and recent Neovim APIs (vim.diagnostic.jump, nvim 0.11 features, tree-sitter-manager instead of the deprecated nvim-treesitter ensure_installed). Highlights for reuse include a small completion/snippet helper that abstracts LuaSnip vs native vim.snippet, color-theory utilities, a floating preview helper, and filetype plugins with proper undo_ftplugin hygiene. Documentation is extensive but partially stale: the README references paths that no longer exist in the tree (e.g. lua/rafi/plugins/lsp/keymaps.lua, lua/rafi/util/contextmenu.lua), so the code is the reliable source of truth. Dependencies: Neovim ≥ 0.11.2, git, lazy.nvim, LazyVim, and roughly 80 third-party Neovim plugins pinned via lazy-lock.json. Optional external CLIs (rg, fd, fzf, bat, zoxide, lazygit) improve picker and git behavior but degrade gracefully. This is not a data repo; it contains no pipelines, notebooks, or datasets. It is an application-distribution-style repo: a carefully engineered editor config demonstrating mature Neovim plugin-spec and Lua patterns.
Zircle is a JavaScript library for building circular, zoomable user interfaces using native custom elements. It recreates the original Zircle component family (z-canvas, z-view, z-spot, z-list, z-dialog) with Orbit for radial layout and Zumly for zoom navigation, eliminating the previous Vue dependency. The library provides a declarative HTML API via templates and a programmatic controller via `createZircle()`, supporting multiple independent canvases, themes, responsive sizing, and accessibility. Internal components include radial knobs, sliders, scrollbars, and pagination, all built with pointer, keyboard, and reduced-motion support. The architecture separates engine concerns: Orbit handles polar geometry and SVG progress rings; Zumly manages view history, zoom transitions, and hash routing; Zircle provides the component vocabulary and canvas lifecycle. Key entry points are the `z-canvas` custom element for declarative usage and the `createZircle()` function for programmatic integration. External dependencies are limited to @zumer/orbit and zumly, and the build produces ESM, standalone ESM, IIFE, and CSS bundles. The codebase demonstrates strong software craftsmanship with thorough browser tests across Chromium, Firefox, and WebKit, TypeScript declarations, a reusable base class (ZSurface) for light-DOM content distribution, and clean separation of control logic in control-utils.js. Several components (z-knob, z-scroll, z-dialog, z-list) implement complex interactive behaviors in a framework-agnostic way, making them valuable references for custom element development.
Madopic is a client-side web application that converts Markdown content into images (PNG, PDF, HTML) with support for mathematical formulas, diagrams, charts, and custom styling. It operates as a single-page application with a split-screen interface: users write Markdown in the left editor and see a live preview on the right. The application processes Markdown through a pipeline that includes syntax highlighting, formula rendering (via KaTeX/mhchem), diagram rendering (via Mermaid), chart rendering (via ECharts), and custom card syntax, all before updating the preview. The application emphasizes a seamless user experience with real-time previews, customizable themes (background, font size, layout), and multiple export options. It implements sophisticated features like offline image persistence using IndexedDB with an in-memory cache, a protected token system to prevent interference between different Markdown extensions (such as preventing math formula replacements inside code blocks), and exact export cloning to ensure that the exported image matches the preview precisely, including handling of specific aspect ratios for platforms like Xiaohongshu and WeChat Moments. Built with vanilla HTML, CSS, and JavaScript, Madopic relies on several CDN-hosted libraries for its core functionality but maintains a lightweight, dependency-conscious architecture. The application is designed as a progressive web app (PWA) and includes features like local draft autosave, keyboard shortcuts, and responsive design to cater to a wide range of use cases from academic to social media content creation.
Video.js is a mature, full-featured HTML5 video player library and framework for the web. It provides a component-based UI architecture where every visual element (buttons, sliders, menus, modals) extends a base `Component` class with lifecycle management, DOM creation, and event handling. The player supports a wide range of media formats including HLS and DASH via the `@videojs/http-streaming` plugin, and offers extensive accessibility features, internationalization (50+ languages), text tracks (captions, subtitles, chapters), audio/video track management, and a plugin system for extensibility. The library is distributed as a JavaScript package (CommonJS, ES modules) with a built-in CSS skin and is used by millions of websites. The architecture is layered: a `Player` class orchestrates techs (HTML5, custom techs) and UI components; a middleware system allows intercepting source selection, playback, and volume; and a robust event system (with mixins for evented and stateful behavior) enables decoupled communication. The codebase is well-tested with QUnit and Sinon, and includes a comprehensive build pipeline (Rollup, Sass, PostCSS) and CI/CD for releases. While the library is actively maintained (v8.24.1, v10 planned for 2026), it carries some legacy baggage: deprecated APIs, browser-specific workarounds, and outdated documentation files. Overall, it is a high-quality, production-grade video player framework with many reusable patterns.
This repository is a frontend UI kit (MDBootstrap) that extends Bootstrap 5 with Material Design components and utilities. It provides a library of interactive UI elements (buttons, modals, dropdowns, etc.) built with JavaScript and SCSS, designed for easy integration into web projects. The architecture follows a modular pattern with separate directories for utilities, DOM helpers, components, and initialization logic. The library includes several reusable low-level components, such as a set of DOM utility functions (for data association, event handling, and element manipulation), a custom perfect scrollbar implementation, and a Material Design ripple effect. These utilities are designed to be isolated and have minimal dependencies, making them suitable for extraction and reuse in other projects. While the project is actively maintained and shows signs of being up-to-date with Bootstrap 5, there is some technical drift risk due to the maintenance of both standard Bootstrap components and MDB-prefixed variants, which may lead to duplication and synchronization challenges. Despite this, the codebase demonstrates solid engineering practices and is widely adopted in the industry.
This repository maintains the HTML Living Standard, the definitive specification for HTML. It processes a Wattsi-formatted source file to generate the HTML specification in multiple formats (single-page, multi-page, and developer's edition). The repository includes automated build and deployment workflows, comprehensive documentation (FAQ, contributing guidelines), and interactive demos showcasing HTML features. Key reusable components include a variable highlighting utility for algorithms, image processing filters, a find-as-you-type search implementation, and a definition lookup panel. The project is actively maintained with recent commits and employs modern web technologies throughout its tooling and demos.
HMPL.js is a lightweight JavaScript library for server-oriented HTML templating. It compiles templates with block helpers (e.g., `{{#request ...}}`) into functions that fetch HTML from a server, sanitize it via DOMPurify, and render it into the DOM. The library supports indicators, memoization, intervals, and status binding, and uses JSON5 for expressive attribute parsing. The core is a single TypeScript module (`src/main.ts`) that exports `compile`, `stringify`, `createWarning`, and `createError`. The repository also contains a comprehensive documentation site built with Astro + Starlight (including Vue interactive components) and a Jekyll blog. The codebase is well-tested with Mocha, Sinon, nock, and jsdom, and has CI/CD via GitHub Actions. It is primarily a frontend library but includes robust build and test infrastructure.