jQuery is a mature, widely-used JavaScript library for DOM manipulation, event handling, AJAX, animations, and cross-browser utilities. The repository contains the full source code (ES modules in `src/`), a comprehensive test suite (QUnit, iframe tests, bundler smoke tests), and build tooling (Rollup, Babel). It is not an application but a library that can be consumed via CommonJS, AMD, ESM, or a global script. The architecture is modular: core utilities, selector engine, event system, deferred/promises, CSS hooks, effects, and AJAX are all separate modules that are compiled into a single distributable. The codebase demonstrates high craftsmanship with well-tested, isolated patterns (e.g., `Callbacks`, `Deferred`, `Data` cache) and extensive cross-browser handling. While some legacy IE workarounds remain, the library has modernized with ES modules, Trusted Types support, and a factory pattern for non-browser environments. The repository is actively maintained with frequent commits, CI workflows for multiple browsers, and a clear release process.
Cheerio is a fast, flexible, and elegant library for parsing and manipulating HTML and XML on the server side (Node.js). It provides a jQuery-like API for traversing and manipulating the DOM of parsed documents, designed for web scraping, data extraction, and HTML transformation tasks. The library abstracts away the underlying parser (htmlparser2 for speed, parse5 for standards compliance) via a factory pattern, offering a consistent Cheerio API regardless of parser choice. Key entry points include the main `load` function that converts HTML strings or buffers into a Cheerio instance, static methods like `html`, `xml`, `text`, and `parseHTML`, and utility functions for CSS handling, form serialization, and attribute manipulation. External dependencies include cheerio-select for CSS selector parsing, domutils for core DOM traversal, and optional HTTP fetching via undici for live URL parsing.
Alpine.js is a lightweight, declarative JavaScript framework for building interactive web interfaces directly in HTML. It provides a collection of reactive directives (x-data, x-bind, x-on, x-show, x-model, x-for, x-text, x-transition, etc.) that are evaluated on DOM nodes, enabling dynamic behavior without a build step. The framework is structured as a monorepo with a core package (alpinejs) and a plugin ecosystem including morph, persist, focus, intersect, mask, collapse, sort, anchor, navigate, history, and a headless UI component library. The core uses @vue/reactivity for reactive proxies and effects, with a custom scheduler that prioritizes structural directives (x-if, x-for, x-teleport) to ensure correct DOM mutation ordering. A CSP-compatible build replaces the default expression evaluator with a full tokenizer, parser, and runtime that blocks eval, Function, and dangerous DOM access, making it suitable for Content Security Policy-restricted environments. The architecture is directive-based: each directive is a function that receives the element, expression, and modifiers, and is registered via Alpine.directive(). Magics ($el, $refs, $store, $watch, $id, etc.) provide reactive access to framework internals. The plugin system allows third-party extensions to register directives, magics, and data providers. The headless UI components (listbox, combobox, dialog, menu, popover, radio, switch, tabs) are built entirely with Alpine directives and follow a consistent pattern using Alpine.bind for attribute/event binding and Alpine.magic for exposing component state. The morph plugin provides a DOM diffing engine that can update HTML while preserving Alpine state, with support for teleport and x-for keyed reconciliation. Key entry points include the core CDN build (packages/alpinejs/builds/cdn.js), the CSP build (packages/csp/builds/cdn.js), and individual plugin builds. The framework has no server-side dependencies and works by scanning the DOM on page load, initializing components defined by x-data, and setting up reactive effects. Data flows from component data (defined in x-data or Alpine.data()) through reactive proxies to DOM updates via directives. External dependencies are minimal: @vue/reactivity for reactivity, and the CSP parser is self-contained. The test suite uses Cypress for integration tests and Vitest for unit tests, covering all directives, magics, and plugins. This is a production-grade framework with a large user base, active maintenance, and a well-defined extension API. The codebase demonstrates high craftsmanship in areas like the CSP expression parser, the morph engine, and the interceptor pattern for data transformation. Some legacy code (old_morph.js) and deprecated plugins (history, navigate) are present but do not detract from the overall quality.
This repository is a Tampermonkey/Greasemonkey userscript that translates the GitHub web interface into Chinese (Simplified and Traditional). It works by loading a dictionary file containing static translations and regex rules, then applying them to the DOM on page load and dynamically via MutationObserver. It includes a sophisticated patch for GitHub's React-based GlobalNav header that carefully times translations to avoid conflicts with React rendering. The repository also contains a VS Code extension that injects the script into VS Code's integrated browser via Chrome DevTools Protocol, enabling translation within the IDE. The codebase is well-structured with clear separation of configuration, state management, and translation logic. It includes a comprehensive test suite for regression testing. The project is actively maintained with frequent updates to keep pace with GitHub's UI changes.
Squire is a rich text editor (RTE) library written in TypeScript, designed primarily for email composition where preserving arbitrary HTML from third-party sources is critical. Unlike modern RTEs that enforce a structured internal data model, Squire keeps the HTML as the source of truth, enabling it to handle complex nested blockquotes, lists, tables, and inline formatting without breaking external markup. It does not provide its own UI toolbar; instead it exposes a programmatic API that can be integrated with any framework, making it lightweight (~16KB gzipped) and flexible. Architecturally, Squire is a single-class library with tightly coupled internal modules for DOM manipulation, range handling, keyboard input, clipboard operations, and HTML cleaning. The core `Squire` class orchestrates a MutationObserver to track changes, manages undo/redo history via HTML snapshots, and intercepts browser default behaviors for keys like Enter, Backspace, Delete, and Tab to provide consistent cross-browser behavior. It supports inline formatting (bold, italic, underline, etc.), block formatting (lists, quotes, code blocks), image resizing, and automatic link detection. Squire is used in production by Fastmail, ProtonMail, Tutanota, Superhuman, and other email services, as well as in non-email apps like Google Earth. Its strength lies in its ability to accept and clean arbitrary HTML through a configurable sanitizer (e.g., DOMPurify) while preserving as much structural fidelity as possible. The codebase is well-maintained with a comprehensive test suite and follows modern ES module practices.
SunEditor is a fully-featured, vanilla JavaScript WYSIWYG HTML editor library designed for modern browsers. It provides a rich text editing experience with extensive formatting options (inline, block, lists, tables, media embedding), multiple display modes (classic, inline, balloon), and a plugin architecture that supports dropdowns, modals, commands, browsers, and input fields. The editor is built around a clean dependency injection kernel, a reducer-based event handling system for keyboard and input events, and a modular structure for UI components (toolbar, menu, controllers) and file management. It includes built-in plugins for images, videos, audio, drawing, math expressions, autocomplete, slash commands, table editing, code view, markdown preview, and document layouts (A4 page breaks). The codebase is extensively tested with unit, integration, and e2e tests (Playwright), and follows strict architectural rules enforced by dependency-cruiser. It exports TypeScript definitions, supports internationalization (20+ languages), and integrates with popular frameworks via official React/Vue wrappers. The library is distributed via npm and CDN, and demonstrates a high level of engineering craftsmanship in its event system, DOM manipulation utilities, and plugin lifecycle management.
TypeFX.js is a modern typewriter effect library implemented in plain JavaScript (with TypeScript source). It provides a fluent API for simulating typing, deleting, cursor movement, and text selection in DOM elements. The library is designed to be framework-agnostic and can be used in vanilla JavaScript, React, Vue, or any other web environment that supports the DOM. The core of the library is the `TypeFX` class, which manages an internal queue of actions to sequence asynchronous operations. It ensures only one instance per DOM element using a WeakMap and supports chaining of methods like `.type()`, `.wait()`, `.delete()`, etc. The library also allows customization of typing speed, caret appearance, and entrance/exit animations via the Web Animations API. The library is distributed as ES modules, CommonJS, and UMD formats via Rollup, with no runtime dependencies. It includes a comprehensive test suite that uses a custom fake DOM implementation to run tests in Node.js, demonstrating good testing practices for DOM-dependent code.
Carbonium is a tiny (1KB) TypeScript library that provides a jQuery-like DOM manipulation utility using JavaScript's Proxy object. It wraps `querySelectorAll` results in a Proxy, allowing property access and method calls to be applied to all matched elements simultaneously. The library supports element creation from HTML strings, handles edge cases like `style`, `classList`, `relList`, array methods (`forEach`, `filter`, etc.), iterators, and empty lists. It has zero runtime dependencies and is published as an npm package with ES module and IIFE bundles. The code is well-structured, thoroughly tested with Playwright across Chromium and Firefox, and includes comprehensive TypeScript type definitions. While the last commit date appears anomalous (2026), the repository shows active maintenance through CI workflows, dependabot, and modern dependency versions.
This repository is a collection of custom macros and systems for Twine/SugarCube 2, a popular interactive fiction authoring tool. It provides reusable components that extend SugarCube 2's functionality, including inventory systems, timekeeping cycles, dialog boxes, notifications, meters, speech boxes, event handling, and various UI enhancements. The architecture consists of individual JavaScript files implementing specific macro systems, with a build process that minifies them for production use. The macros interact with SugarCube 2's state and DOM APIs to modify story behavior and presentation. Key entry points are the macro definitions themselves, which users include in their Twine story's JavaScript section. The system demonstrates solid engineering practices with well-encapsulated components, proper event handling, and thoughtful API design.
A browser extension (ImprovedTube) that provides 80+ configuration options to customize YouTube's appearance and behavior. It injects CSS and JavaScript into YouTube pages to modify the player, sidebar, comments, thumbnails, themes, and more. Features include ad blocking, forced playback parameters, keyboard shortcuts, a blocklist for channels/videos, smart speed based on heatmap data, and integration with Return YouTube Dislike. The extension uses a message-passing architecture between content scripts and page-world scripts via custom DOM events, and a custom Satus UI framework for the settings panel. It is localized into 40+ languages but has a high number of open issues and dependencies on fragile YouTube DOM structures. The codebase is functionally comprehensive but shows signs of maintenance drift with hardcoded API keys, heavy use of !important CSS, and incomplete locale coverage.
This repository contains the starter files and completed solutions for Wes Bos's 'JavaScript30' course - a collection of 30 vanilla JavaScript exercises, each a self-contained mini-application demonstrating a specific browser API or JavaScript pattern. The exercises cover: DOM manipulation and events (Drum Kit, Clock, Whack-a-Mole), modern array methods (Array Cardio Days 1-2), localStorage persistence, HTML5 Canvas drawing, custom video player controls, speech recognition/synthesis, webcam/media devices API, geolocation, CSS variables manipulation, flexbox transitions, sticky navigation, drag-to-scroll, type-ahead autocomplete, shift-click range selection, konami code detection, scroll-triggered animations, dropdown navigation, link highlighting, and various console/debugging techniques. Each exercise exists as a pair: START (boilerplate HTML/CSS) and FINISHED (working solution). The code is intentionally written as inline scripts in HTML files to match the video tutorials, not as modular, reusable components. There are no build tools, test suites, or dependency management (except browser-sync for live-reload in a few exercises). The repo is actively maintained to stay in sync with the course videos, but the content is pedagogically frozen - PRs that improve code but deviate from the videos are explicitly rejected.
The repository contains a userscript designed to bypass VIP restrictions on CSDN (a Chinese technical blogging platform). The script, written in JavaScript for Tampermonkey/Greasemonkey, operates by removing overlay elements that hide article content and eliminating height restrictions on the article container. Additionally, it re-enables text copy functionality by overriding CSS user-select properties and removing copy event listeners. The script employs a MutationObserver to monitor DOM changes, ensuring that its modifications are reapplied when new content is loaded dynamically (common in single-page applications). It also initializes its adjustments upon window load. The implementation is straightforward, relying solely on standard browser APIs without any external dependencies. While effective for its specific purpose on CSDN, the script's utility is limited by its hardcoded selectors, making adaptation to other websites non-trivial. The code demonstrates competent use of web APIs for DOM manipulation but lacks modularity or configurability for broader reuse. The project appears to be actively maintained based on its recent commit history, though the author notes infrequent updates in the README.