Browser Web API Demonstrations

Parse XML or HTML string templates into DOM Document objects using DOMParser.

Sanatize untrusted HTML strings before insertion into the DOM using the native Sanitizer API.

Enforce safe HTML, script, and URL assignment to prevent Cross-Site Scripting (XSS).

Construct lightweight, off-screen DOM subtree nodes for high-performance DOM manipulation.

Represent a fragment of a document that can contain nodes and parts of text nodes.

Inspect and manipulate the range of text selected by the user in the document.

Traverse nodes of a DOM subtree using specified node types and filter conditions.

Iterate sequentially over a filtered list of DOM nodes in document order.

Watch for structural and attribute changes made to the DOM tree.

Asynchronously observe changes in the intersection of a target element with a ancestor or viewport.

Observe changes to an Element's content or border box dimensions.

Check element bounding rectangle visibility and viewport placement.

Verify DOM sanitization behavior and XSS prevention policies.

Create and inspect TrustedHTML policy tokens for secure innerHTML injection.

Create and inspect TrustedScript objects for safe inline script execution.

Validate external script URL origins using TrustedScriptURL policies.

Inspect active browser Trusted Types policies and default sink behavior.

Test element.insertAdjacentHTML and DOM parser safety against script execution.

Audit browser DOM injection sinks (innerHTML, outerHTML, document.write).

Read text and data asynchronously from the system clipboard using navigator.clipboard.

Write arbitrary text directly to the system clipboard.

Read and write image Blob objects (PNG/JPEG) from the system clipboard.

Copy and read rich HTML formatted data from system clipboard.

Intercept copy, cut, and paste DOM clipboard events.

Trigger native system share dialog for text, URLs, or document files.

Verify navigator.canShare() file sharing support and pass File objects to native share target.

Asynchronously read contents of local files as Data URLs, Text, or ArrayBuffer.

Inspect File object metadata including name, size, type, and lastModified timestamp.

Open native system open-file picker dialog using showOpenFilePicker.

Request directory access and iterate local folder structures using showDirectoryPicker.

Prompt native system save-file picker using showSaveFilePicker.

Direct read and write access to local files with FileSystemHandle permissions.

Stream content directly to local files using FileSystemWritableFileStream.

High-performance private sandboxed storage space optimized for databases and workers.

Estimate disk space quota usage and request persistent storage quota.

Low-level transactional database for storing large amounts of structured client-side data.

Store network Request/Response pairs for offline usage and PWA asset caching.

Perform asynchronous HTTP network requests with promise-based fetch().

Inspect and construct HTTP Request objects including mode, credentials, and headers.

Construct synthetic HTTP Response instances with custom status codes and streams.

Manipulate HTTP header key-value maps with get, set, append, and delete methods.

Construct key/value payload pairs representing form fields and binary files.

Parse, construct, and validate absolute URLs, protocols, ports, and pathnames.

Utility methods to work with the query string of a URL.

Match URLs against standardized pattern templates using wildcard path segments.

Establish persistent two-way interactive communication sessions between browser and server.

Receive real-time Server-Sent Events over HTTP connection.

Low-latency bidirectional client-server streaming over HTTP/3 / QUIC protocols.

Inspect connection connection type (4g/wifi), effective type, and saveData settings.

Construct and consume readable byte data streams incrementally.

Stream output destination interface for chunked data processing.

Pipeline transform layer between readable and writable streams.

Compress data streams natively using gzip, deflate, or deflate-raw algorithms.

Decompress raw compressed byte streams in real-time.

Encode JavaScript UTF-8 text strings into Uint8Array binary buffers.

Decode binary byte arrays into JavaScript UTF-8 strings.

Stream Blob binary file data using blob.stream().

Enumerate connected audio inputs, webcams, and speaker hardware devices.

Capture live camera video streams using navigator.mediaDevices.getUserMedia.

Capture live microphone audio streams.

Record live media streams (audio/video) into WebM or MP4 blobs.

Capture live screen share streams using navigator.mediaDevices.getDisplayMedia.

Combine getDisplayMedia screen capture with MediaRecorder to save MP4/WebM screen recordings.

Buffer and play video streams dynamically using MediaSource API.

Float video elements in a floating overlay window.

Select physical audio output speaker devices using selectAudioOutput / setSinkId.

Query playback and encoding smoothness & power efficiency for specific audio/video codecs.

Render 2D shapes, text, images, and paths on a 2D canvas context.

Render canvas graphics in background web workers detached from DOM.

Create high-performance bitmap textures asynchronously with createImageBitmap.

Direct RGBA pixel buffer manipulation using ImageData array objects.

Hardware-accelerated 3D graphics rendering engine in the browser.

Enhanced 3D graphics API bringing OpenGL ES 3.0 feature set to browsers.

Next-generation low-overhead GPU compute and 3D rendering pipeline.

Low-level primitive access to hardware video and audio encoders and decoders.

Retrieve device geographical location coordinates (latitude, longitude, accuracy).

Detect physical orientation tilt angles (alpha, beta, gamma).

Measure device acceleration and rate of rotation along 3 axes.

Monitor battery charge percentage, charging state, and discharge timer.

Read current screen orientation state (portrait/landscape) and lock orientation.

Query multi-monitor arrangements and screen color depths.

Generic Sensor API for 3-axis acceleration tracking.

Generic Sensor API for angular velocity tracking.

Generic Sensor API measuring magnetic field intensity.

Read ambient room illuminance levels in Lux units.

Connect and interact with nearby Bluetooth Low Energy (BLE) peripheral devices.

Communicate directly with microcontrollers and serial port devices (Arduino/Raspberry Pi).

Connect directly to USB hardware devices from web applications.

Interact with Human Interface Devices (gamepads, keypads, custom controllers).

Connect MIDI synthesizers, keyboards, and controllers.

Read and write NDEF tags over Near Field Communication.

Request and exit full-screen presentation mode for document elements.

Prevent screen from dimming or sleeping during active tool usage.

Display system desktop notifications to the user.

Trigger haptic vibration patterns on mobile devices.

Set document badge numbers or indicators on OS taskbar/dock icons.

Detect when the browser tab is hidden or backgrounded.

Open arbitrary HTML element windows in a floating picture-in-picture window.

Native top-layer popover content UI without z-index conflicts.

Animate smooth visual transitions between DOM states.

Control CSS keyframe animation pipelines directly with JavaScript.

Run background JavaScript tasks on separate worker threads without blocking the main UI thread.

Share background worker threads across multiple browser tabs and windows.

Background event-driven worker for offline caching and push notifications.

Send messages across same-origin browser tabs and windows.

Create direct two-way channel communication ports between workers/iframes.

Coordinate resource locks across multiple tabs and workers.

Defer server actions until user has a stable network connection.

Queue non-essential tasks during browser idle time using requestIdleCallback.

Standard cryptographic primitives interface available on crypto namespace.

Perform hardware cryptographic hashing (SHA-256), encryption (AES-GCM), and signatures (HMAC/RSA).

Generate cryptographically secure random values with crypto.getRandomValues.

Passwordless authentication using biometric sensors and physical security keys.

Store and retrieve user authentication credentials securely.

Programmatically read SMS verification one-time passwords.

Query permission state ('granted', 'denied', 'prompt') for browser capabilities.

Inspect DOM XSS sink protection rules and CSP enforcement.

High-resolution millisecond timestamp measurement using performance.now().

Observe real-time metric entries (paint, layout-shift, resource) as they occur.

Inspect document load timing milestones (DNS, connect, DOMContentLoaded, load).

Detailed network fetch duration metrics for page resources (scripts, images, css).

Measure First Paint (FP) and First Contentful Paint (FCP) metrics.

Detect UI main-thread execution tasks that exceed 50 milliseconds.

Create custom application performance benchmarks using performance.mark and measure.

Prioritize task execution queues using scheduler.postTask with user-blocking or background priorities.

Unified input hardware handler for mouse, touch screen, and digital pen stylus inputs.

Lock the mouse pointer inside canvas or element bounds for 3D games and controls.

Inspect physical key layouts and capture physical key presses using Keyboard Map API.

Connect and read USB/Bluetooth gamepad joystick & button controller inputs.

HTML5 native element drag and file drop events.

Multi-touch gesture input tracking for smartphones and touchscreens.

Control software keyboard layout overlay and geometry changes on mobile devices.

Inspect navigator details including online state, platform, cookie state, and vendor.

Inspect the browser navigator.userAgent string.

Query modern User-Agent Client Hints (sec-ch-ua, mobile, platform, architecture).

Inspect screen resolution, color depth, pixel ratio, and available width/height.

Measure viewport inner/outer dimensions, scroll position, and frame geometry.

Inspect system preferred languages array navigator.languages.

Query user's local IANA timezone name and UTC offset.

Inspect device approximate RAM memory capacity in gigabytes.

Query logical CPU core thread count navigator.hardwareConcurrency.