@tradik/xslt-processor 1.0.3 → 1.3.0

package/README.md

@@ -1,31 +1,62 @@
 # @tradik/xslt-processor
 
+[![GitHub](https://img.shields.io/badge/GitHub-Repository-181717?logo=github)](https://github.com/spagu/XSLT-Processor)
+[![GitHub stars](https://img.shields.io/github/stars/spagu/XSLT-Processor?style=social)](https://github.com/spagu/XSLT-Processor/stargazers)
+[![GitHub forks](https://img.shields.io/github/forks/spagu/XSLT-Processor?style=social)](https://github.com/spagu/XSLT-Processor/network/members)
+
 [![CI](https://github.com/spagu/XSLT-Processor/actions/workflows/test.yml/badge.svg)](https://github.com/spagu/XSLT-Processor/actions/workflows/test.yml)
+[![Browser tests](https://github.com/spagu/XSLT-Processor/actions/workflows/browser.yml/badge.svg)](https://github.com/spagu/XSLT-Processor/actions/workflows/browser.yml)
 [![Release](https://github.com/spagu/XSLT-Processor/actions/workflows/release.yml/badge.svg)](https://github.com/spagu/XSLT-Processor/actions/workflows/release.yml)
 [![npm version](https://img.shields.io/npm/v/@tradik/xslt-processor.svg)](https://www.npmjs.com/package/@tradik/xslt-processor)
 [![License: BSD-3-Clause](https://img.shields.io/badge/License-BSD--3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
-[![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
-[![Test Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen.svg)](https://github.com/spagu/XSLT-Processor)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.19.0-brightgreen.svg)](https://nodejs.org/)
+[![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=spagu_XSLT-Processor&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=spagu_XSLT-Processor)
+[![Line Coverage](https://img.shields.io/badge/line%20coverage-100%25-brightgreen.svg)](docs/CONFORMANCE.md#test-coverage)
+[![TypeScript](https://img.shields.io/badge/types-included-3178c6.svg?logo=typescript&logoColor=white)](docs/API.md#typescript)
+
+> **Source Code:** [github.com/spagu/XSLT-Processor](https://github.com/spagu/XSLT-Processor)
 
 JavaScript implementation of XSLTProcessor for browser environments and Node.js CLI. This package provides a complete implementation of the W3C XSLTProcessor API that can be used as a drop-in replacement for the native browser implementation.
 
 ## Background
 
-Chrome and other browsers are deprecating native XSLTProcessor support:
-- **Chrome 143+**: XSLTProcessor starts showing deprecation warnings
-- **Chrome 164 (August 2027)**: Full removal of native XSLT support
+Chrome and other browsers are removing native XSLT ([Chrome's announcement](https://developer.chrome.com/docs/web-platform/deprecating-xslt)):
+- **Chrome 143 (December 2025)**: `XSLTProcessor` and `<?xml-stylesheet type="text/xsl"?>` are deprecated, with warnings in the console
+- **Chrome 158 (17 November 2026)**: XSLT stops working in stable Chrome, except for sites in the origin trial and browsers under the enterprise policy
+- **Chrome 176 (17 August 2027)**: the origin trial and the enterprise policy end; XSLT is off everywhere
+- Firefox and WebKit support the removal but have not announced dates
 
 This library ensures your XSLT-based applications continue to work regardless of browser support.
 
 ## Features
 
 - **1:1 Native API Compatibility**: Drop-in replacement for native `XSLTProcessor`
-- **Full XSLT 1.0 Support**: Implements the complete W3C XSLT 1.0 specification
+- **XSLT 1.0**: Every element and function of the W3C XSLT 1.0 Recommendation, with the few gaps listed under [Known Deviations](docs/CONFORMANCE.md#known-deviations)
 - **XPath 1.0 Engine**: Built-in XPath evaluator with all core functions
-- **Zero Dependencies**: Standalone implementation with no external dependencies
+- **`xsl:output` Serialization**: `transformToString()` honors method, indent, doctype, CDATA sections and `disable-output-escaping`
+- **Zero Dependencies**: The library has no runtime dependencies; only the `xslt` command line tool needs `jsdom` (an optional peer dependency)
 - **Multiple Formats**: ESM, CommonJS, and browser IIFE bundles
 - **TypeScript Support**: Includes TypeScript declarations
-- **WCAG 2.2 Compliant**: Designed with accessibility in mind
+
+## Documentation
+
+The documentation is also published as a website with an interactive playground: <https://xslt-processor.tradik.com/> ([playground](https://xslt-processor.tradik.com/playground/): XSLT 1.0 transformations, and with the in-development `@tradik/xslt3` XSLT 3.0 stylesheets at [?mode=xslt3](https://xslt-processor.tradik.com/playground/?mode=xslt3) and XPath 3.1 expressions at [?mode=xpath](https://xslt-processor.tradik.com/playground/?mode=xpath); [blog](https://xslt-processor.tradik.com/blog/) with an [RSS feed](https://xslt-processor.tradik.com/blog/rss.xml)).
+
+| Guide | Contents |
+|-------|----------|
+| [API Reference](docs/API.md) | `XSLTProcessor` methods, parameters, `xsl:output` serialization, module exports, `XsltEngine` options, TypeScript |
+| [Loaders](docs/LOADERS.md) | `xsl:import`, `xsl:include` and the `document()` function |
+| [Complete Example](docs/EXAMPLES.md) | A product list transformed into an HTML table (browser and CLI) |
+| [Command Line Tool](docs/CLI.md) | `xslt` options, base directory, includes, input encodings |
+| [Conformance](docs/CONFORMANCE.md) | W3C compliance tables, supported elements and functions, known deviations, test coverage |
+| [Security Limits](docs/SECURITY-LIMITS.md) | XPath and XSLT limits, prototype pollution protection, input validation |
+| [Browser Compatibility](docs/BROWSER-SUPPORT.md) | Minimum browser versions, native XSLT removal timeline, feature detection |
+| [XSLT 2.0 and 3.0](docs/XSLT3.md) | In development: one engine for XSLT 3.0 and 2.0 in a separate package, `@tradik/xslt3`; design, scope and milestones |
+| [Benchmarks](docs/BENCHMARKS.md) | 1.1.3 vs 1.2.0: speed-up, time and peak memory per scenario, with charts, tables and `npm run bench` to reproduce; XPath 1.0 of this package vs XPath 3.1 of @tradik/xslt3 (`npm run bench -- --suite xpath`); the XSLT 1.0 engine vs @tradik/xslt3 on the same stylesheets, idiomatic 2.0/3.0 rewrites and 3.0-only scenarios (`npm run bench -- --suite xslt`) |
+| [Development](docs/DEVELOPMENT.md) | Setup, tests, Docker, Makefile, publishing to npm |
+| [Style Guide](docs/STYLE-GUIDE.md) | Project colors with WCAG 2.2 contrast ratios |
+
+All guides are listed in the [documentation index](docs/README.md).
 
 ## Installation
 
@@ -33,7 +64,10 @@ This library ensures your XSLT-based applications continue to work regardless of
 npm install @tradik/xslt-processor
 ```
 
-## Usage
+The library itself has no dependencies. The `xslt` command line tool also
+needs `jsdom` (an optional peer dependency, `>=25`), see [CLI Usage](#cli-usage).
+
+## Quick Start
 
 ### Browser via CDN (Recommended)
 
@@ -47,7 +81,7 @@ Use a CDN for the easiest browser integration - no build step required:
 <script src="https://unpkg.com/@tradik/xslt-processor@1/dist/xslt-processor.browser.min.js"></script>
 
 <script>
-  // XSLTProcessor is now available globally
+  // XSLTProcessor is the native one, or this polyfill when native XSLT is unavailable
   const processor = new XSLTProcessor();
 
   // Load and transform XML
@@ -61,13 +95,20 @@ Use a CDN for the easiest browser integration - no build step required:
 </script>
 ```
 
+The bundle defines the global `XsltProcessorLib` (all [module exports](docs/API.md#module-exports))
+and calls `installGlobal()`: `window.XSLTProcessor` is replaced only when the
+browser has no working native implementation. To always use this
+implementation, call `XsltProcessorLib.installGlobal(true)` or use
+`new XsltProcessorLib.XSLTProcessor()`.
+
 **CDN URLs:**
+
 | CDN | URL |
 |-----|-----|
 | jsDelivr | `https://cdn.jsdelivr.net/npm/@tradik/xslt-processor@1/dist/xslt-processor.browser.min.js` |
 | unpkg | `https://unpkg.com/@tradik/xslt-processor@1/dist/xslt-processor.browser.min.js` |
 
-> **Tip:** Use `@1` for latest 1.x version, or `@1.0.0` for exact version pinning.
+> **Tip:** Use `@1` for the latest 1.x version, or an exact version such as `@1.1.3` for pinning.
 
 ### Browser (Local Install)
 
@@ -117,546 +158,95 @@ const processor = new XSLTProcessor();
 // ...
 ```
 
-### CLI Usage
-
-The package includes a command-line tool for transforming XML documents:
-
-```bash
-# Global installation
-npm install -g @tradik/xslt-processor
-
-# Transform XML with XSLT
-xslt data.xml template.xsl
-
-# Save output to file
-xslt data.xml template.xsl -o result.html
-
-# With parameters
-xslt data.xml template.xsl -p title="My Page" -p count=10
-
-# Format output with indentation
-xslt data.xml template.xsl -f -o output.html
-```
-
-#### CLI Options
-
-| Option | Description |
-|--------|-------------|
-| `-o, --output <file>` | Write output to file instead of stdout |
-| `-p, --param <n>=<v>` | Set XSLT parameter (can be used multiple times) |
-| `-f, --format` | Format output with indentation |
-| `-h, --help` | Show help message |
-| `-v, --version` | Show version number |
+### Node.js
 
-## API Reference
+Node.js has no DOM, so bring one such as `jsdom`. The
+[filesystem loader example](docs/LOADERS.md#nodejs-example-filesystem-loader)
+is a complete Node.js script, and the [API Reference](docs/API.md) covers every
+method.
 
-### XSLTProcessor
+### XSLT 2.0 and 3.0 (opt-in)
 
-#### Constructor
+By default every stylesheet runs with the XSLT 1.0 engine, and a
+`version="2.0"` stylesheet runs in forwards-compatible mode, as in Chrome.
+With `xsltVersion: "auto"`, a stylesheet that declares version 2.0 or 3.0 is
+run by [`@tradik/xslt3`](docs/XSLT3.md), an optional peer dependency loaded
+with `import()` only when such a stylesheet is imported, so the XSLT 1.0
+bundles do not grow by the size of the new engine:
 
 ```javascript
-const processor = new XSLTProcessor();
-```
-
-#### Methods
-
-| Method | Description |
-|--------|-------------|
-| `importStylesheet(node)` | Imports an XSLT stylesheet from a Document or Element node |
-| `transformToFragment(source, output)` | Transforms XML and returns a DocumentFragment |
-| `transformToDocument(source)` | Transforms XML and returns an XMLDocument |
-| `setParameter(namespaceURI, localName, value)` | Sets an XSLT parameter |
-| `getParameter(namespaceURI, localName)` | Gets an XSLT parameter value |
-| `removeParameter(namespaceURI, localName)` | Removes an XSLT parameter |
-| `clearParameters()` | Removes all parameters |
-| `reset()` | Resets the processor, removing stylesheet and parameters |
-
-### Parameters Example
-
-```javascript
-const processor = new XSLTProcessor();
-processor.importStylesheet(xsltDoc);
-
-// Set parameters
-processor.setParameter(null, 'sortOrder', 'ascending');
-processor.setParameter(null, 'itemsPerPage', 10);
-
-// Get parameter
-const sortOrder = processor.getParameter(null, 'sortOrder');
-
-// Clear parameters
-processor.clearParameters();
-```
-
-### Using xsl:import and xsl:include
-
-To use `xsl:import` and `xsl:include` elements in your stylesheets, you need to configure a stylesheet loader that tells the processor how to fetch external stylesheets:
-
-```javascript
-import { XSLTProcessor } from '@tradik/xslt-processor';
-
-const processor = new XSLTProcessor();
-
-// Configure stylesheet loader
-processor.engine.setStylesheetLoader((href, baseUri) => {
-  // href: the href attribute from xsl:import/xsl:include
-  // baseUri: the URI of the importing stylesheet
-
-  // Option 1: Return a parsed Document
-  const response = await fetch(href);
-  const text = await response.text();
-  const parser = new DOMParser();
-  return parser.parseFromString(text, 'application/xml');
-
-  // Option 2: Return XML string (will be parsed automatically)
-  return await fetch(href).then(r => r.text());
-});
-
-// Now xsl:import and xsl:include will work
-processor.importStylesheet(mainStylesheet, '/styles/main.xsl');
-```
-
-#### Import vs Include Behavior
-
-- **xsl:include**: Merges templates at the same precedence level. If multiple templates match, priority attribute decides.
-- **xsl:import**: Imported templates have lower precedence than importing stylesheet. The importing stylesheet's templates always win over imported ones with the same match pattern.
-
-```xml
-<!-- main.xsl -->
-<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
-  <xsl:import href="base.xsl"/>  <!-- imported templates have lower precedence -->
-  <xsl:include href="utils.xsl"/> <!-- included templates have same precedence -->
-
-  <xsl:template match="item">
-    <!-- This template overrides the one from base.xsl -->
-  </xsl:template>
-</xsl:stylesheet>
-```
+// npm install @tradik/xslt3
+const processor = new XSLTProcessor({ xsltVersion: "auto" });
+const html = await processor.transformAsync(xmlText, { stylesheet: xsl20Text });
 
-### Utility Functions
-
-```javascript
-import { isNativeXSLTSupported, installGlobal } from '@tradik/xslt-processor';
-
-// Check if native XSLT is functional
-if (!isNativeXSLTSupported()) {
-  console.log('Using JS implementation');
-}
-
-// Install as global XSLTProcessor
-installGlobal(); // Only if native not available
-installGlobal(true); // Force install
-```
-
-## Complete Example
-
-Here's a full example transforming a list of products into an HTML table:
-
-**products.xml:**
-```xml
-<?xml version="1.0"?>
-<products>
-  <product id="1">
-    <name>Widget</name>
-    <price>29.99</price>
-    <stock>150</stock>
-  </product>
-  <product id="2">
-    <name>Gadget</name>
-    <price>49.99</price>
-    <stock>75</stock>
-  </product>
-</products>
-```
-
-**products.xsl:**
-```xml
-<?xml version="1.0"?>
-<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
-  <xsl:param name="title" select="'Product Catalog'"/>
-
-  <xsl:template match="/">
-    <html>
-      <head><title><xsl:value-of select="$title"/></title></head>
-      <body>
-        <h1><xsl:value-of select="$title"/></h1>
-        <table>
-          <tr><th>ID</th><th>Name</th><th>Price</th><th>Stock</th></tr>
-          <xsl:apply-templates select="products/product">
-            <xsl:sort select="name"/>
-          </xsl:apply-templates>
-        </table>
-      </body>
-    </html>
-  </xsl:template>
-
-  <xsl:template match="product">
-    <tr>
-      <td><xsl:value-of select="@id"/></td>
-      <td><xsl:value-of select="name"/></td>
-      <td>$<xsl:value-of select="price"/></td>
-      <td>
-        <xsl:choose>
-          <xsl:when test="stock > 100">In Stock</xsl:when>
-          <xsl:when test="stock > 0">Low Stock</xsl:when>
-          <xsl:otherwise>Out of Stock</xsl:otherwise>
-        </xsl:choose>
-      </td>
-    </tr>
-  </xsl:template>
-</xsl:stylesheet>
-```
-
-**JavaScript:**
-```javascript
-import { XSLTProcessor } from '@tradik/xslt-processor';
-
-const processor = new XSLTProcessor();
-processor.importStylesheet(xsltDoc);
-processor.setParameter(null, 'title', 'My Product List');
-
-const result = processor.transformToFragment(xmlDoc, document);
-document.body.appendChild(result);
-```
-
-**CLI:**
-```bash
-xslt products.xml products.xsl -p title="My Product List" -f -o catalog.html
+// The synchronous W3C API needs the engine loaded first
+await XSLTProcessor.preload();
+processor.importStylesheet(xsl20Doc);
+const fragment = processor.transformToFragment(xmlDoc, document);
 ```
 
-## Security Features
-
-The XPath evaluator includes comprehensive security hardening to prevent common attack vectors.
-
-### DoS Prevention Limits
-
-| Limit | Default | Description |
-|-------|---------|-------------|
-| `MAX_RECURSION_DEPTH` | 100 | Prevents stack overflow from deeply nested expressions |
-| `MAX_RESULT_SIZE` | 10,000 | Prevents memory exhaustion from large result sets |
-| `MAX_STRING_LENGTH` | 1,000,000 | Limits string processing to prevent memory issues |
-
-### Prototype Pollution Protection
-
-The following variable names are blocked:
-- `__proto__`, `constructor`, `prototype`
-- `__defineGetter__`, `__defineSetter__`
-- `__lookupGetter__`, `__lookupSetter__`
-
-### Input Validation
-
-- **AST Validation**: All AST nodes are validated before evaluation
-- **Type Safety**: Strict type checking on all inputs
-- **Safe Variable Lookup**: Uses `hasOwnProperty` to prevent prototype chain attacks
-
-### Custom Security Limits
-
-```javascript
-import { XPathEvaluator, XPathContext, parse } from '@tradik/xslt-processor';
-
-const evaluator = new XPathEvaluator({
-  maxRecursionDepth: 50,    // Lower for untrusted input
-  maxResultSize: 1000,      // Limit result set size
-  maxStringLength: 10000    // Limit string operations
-});
-
-const ast = parse('//item');
-const context = new XPathContext(xmlDoc);
-const result = evaluator.evaluate(ast, context);
-```
+The CLI flag is `--xslt-version auto`. Details: [Opt-in XSLT 2.0/3.0](docs/API.md#opt-in-xslt-2030).
 
-## XSLT Elements Supported
-
-| Element | Status |
-|---------|--------|
-| `xsl:apply-templates` | Supported |
-| `xsl:attribute` | Supported |
-| `xsl:call-template` | Supported |
-| `xsl:choose` / `when` / `otherwise` | Supported |
-| `xsl:comment` | Supported |
-| `xsl:copy` | Supported |
-| `xsl:copy-of` | Supported |
-| `xsl:element` | Supported |
-| `xsl:for-each` | Supported |
-| `xsl:if` | Supported |
-| `xsl:message` | Supported |
-| `xsl:number` | Supported |
-| `xsl:output` | Supported |
-| `xsl:param` | Supported |
-| `xsl:processing-instruction` | Supported |
-| `xsl:sort` | Supported |
-| `xsl:template` | Supported |
-| `xsl:text` | Supported |
-| `xsl:value-of` | Supported |
-| `xsl:variable` | Supported |
-| `xsl:with-param` | Supported |
-| `xsl:import` | Supported |
-| `xsl:include` | Supported |
-
-## XPath Functions Supported
-
-### Node Set Functions
-- `count()`, `id()`, `last()`, `local-name()`, `name()`, `namespace-uri()`, `position()`
-
-### String Functions
-- `concat()`, `contains()`, `normalize-space()`, `starts-with()`, `string()`, `string-length()`, `substring()`, `substring-after()`, `substring-before()`, `translate()`
-
-### Boolean Functions
-- `boolean()`, `false()`, `lang()`, `not()`, `true()`
-
-### Number Functions
-- `ceiling()`, `floor()`, `number()`, `round()`, `sum()`
-
-## Development
-
-### Prerequisites
-
-- Node.js 25+ (for native test runner)
-- Docker (optional, for containerized testing)
-
-### Setup
+## CLI Usage
 
-```bash
-cd services/xslt-processor
-npm install
-```
+The package includes a command-line tool for transforming XML documents.
 
-### Commands
+Without Node.js, use the standalone executable attached to every GitHub
+release (Linux x64/arm64, macOS x64/arm64, Windows x64), installed with a
+checksum check:
 
 ```bash
-# Run tests
-npm test
-
-# Run tests with watch mode
-npm run test:watch
-
-# Build bundles
-npm run build
-
-# Lint code
-npm run lint
-
-# Format code
-npm run format
+curl -fsSL https://raw.githubusercontent.com/spagu/XSLT-Processor/main/scripts/install.sh | bash
 ```
 
-### Docker
+See [Standalone executables](docs/CLI.md#standalone-executables) for manual
+installation. With Node.js, the command line tool needs a DOM implementation, so install `jsdom` next to
+the package. It is an optional peer dependency: library users do not need it.
+Without it, `xslt` exits with an explanation instead of a stack trace.
 
 ```bash
-# Run tests in container
-docker-compose run test
-
-# Development with hot reload
-docker-compose run dev
-
-# Build bundles
-docker-compose run build
-```
-
-### Publishing to npm
+# Global installation
+npm install -g @tradik/xslt-processor jsdom
 
-The package is automatically published to npm when a GitHub release is created or a version tag is pushed.
+# Transform XML with XSLT
+xslt data.xml template.xsl
 
-**Prerequisites:**
-1. Set up `NPM_TOKEN` secret in GitHub repository settings
-2. Ensure version in `package.json` matches the release tag
+# Save output to file
+xslt data.xml template.xsl -o result.html
 
-**Release Process:**
+# With parameters
+xslt data.xml template.xsl -p title="My Page" -p count=10
 
-```bash
-# 1. Update version in package.json
-npm version patch  # or minor, major
+# Format output with indentation
+xslt data.xml template.xsl -f -o output.html
 
-# 2. Push the tag
-git push origin --tags
+# Override the output method and drop the XML declaration
+xslt data.xml template.xsl --method text
+xslt data.xml template.xsl --no-declaration
 
-# 3. Create a GitHub release (or push triggers automatically)
+# Run an XSLT 2.0/3.0 stylesheet with @tradik/xslt3 (npm install -g @tradik/xslt3)
+xslt data.xml grouping.xsl --xslt-version auto
 ```
 
-**Automated Workflow:**
-1. Runs all tests and linting checks
-2. Performs security audit with `npm audit`
-3. Builds distribution bundles
-4. Publishes to npm with provenance (supply chain security)
-5. Uploads build artifacts to GitHub
-
-## Browser Compatibility
-
-This library provides a JavaScript polyfill for XSLTProcessor that works across all modern browsers.
-
-### Polyfill Support
+See [Command Line Tool](docs/CLI.md) for all options, the base directory,
+`xsl:include`/`document()` resolution and input encodings.
 
-| Browser | Minimum Version | ES Modules | Status |
-|---------|-----------------|------------|--------|
-| Chrome | 90+ | Yes | Fully Supported |
-| Firefox | 88+ | Yes | Fully Supported |
-| Safari | 14+ | Yes | Fully Supported |
-| Edge | 90+ | Yes | Fully Supported |
-| Opera | 76+ | Yes | Fully Supported |
-| Samsung Internet | 15+ | Yes | Fully Supported |
-| Node.js | 25+ | Yes | Fully Supported |
+## Known Deviations
 
-### Native XSLT Deprecation Timeline
+The main differences from XSLT 1.0 / XPath 1.0 and from libxslt:
 
-| Browser | Deprecation Warning | Full Removal |
-|---------|---------------------|--------------|
-| Chrome | v143 (2026) | v164 (August 2027) |
-| Edge | v143 (2026) | v164 (August 2027) |
-| Other Chromium | v143 (2026) | v164 (August 2027) |
+- `xsl:number` ignores `lang` and `letter-value`;
+- `unparsed-entity-uri()` always returns `''`;
+- numbers convert to strings in the XPath 1.0 form (`10000000000`), where libxslt writes `1e+10`.
 
-### Feature Detection
+Details and workarounds: [Known Deviations](docs/CONFORMANCE.md#known-deviations).
 
-```javascript
-import { isNativeXSLTSupported, installGlobal } from '@tradik/xslt-processor';
-
-// Check native support and auto-install polyfill
-if (!isNativeXSLTSupported()) {
-  installGlobal();
-  console.log('Using JavaScript XSLT polyfill');
-}
-```
+## Contributing and Security
 
-## W3C Standards Compliance
-
-This implementation follows these W3C specifications with comprehensive test coverage to ensure compliance.
-
-### Specifications Implemented
-
-| Specification | Version | Status |
-|---------------|---------|--------|
-| [XPath 1.0](http://www.w3.org/TR/1999/REC-xpath-19991116) | W3C Recommendation, 16 November 1999 | Full Compliance |
-| [XSLT 1.0](http://www.w3.org/TR/1999/REC-xslt-19991116) | W3C Recommendation, 16 November 1999 | Full Compliance |
-| [DOM Level 3 Core](http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/) | W3C Recommendation, 7 April 2004 | Full Compliance |
-
-### XSLT 1.0 Specification Compliance
-
-| Section | Feature | Status | Notes |
-|---------|---------|--------|-------|
-| 2 | Stylesheet Structure | Supported | `xsl:stylesheet`, `xsl:transform` elements |
-| 3 | Data Model | Supported | Seven node types per XPath data model |
-| 5 | Template Rules | Supported | Pattern matching, priority calculation |
-| 5.1 | Processing Model | Supported | Built-in templates for all node types |
-| 5.2 | Patterns | Supported | All pattern syntax including predicates |
-| 5.3 | Defining Template Rules | Supported | `match`, `name`, `priority`, `mode` attributes |
-| 5.4 | Applying Template Rules | Supported | `xsl:apply-templates` with `select`, `mode` |
-| 5.5 | Conflict Resolution | Supported | Import precedence and priority ordering |
-| 6 | Named Templates | Supported | `xsl:call-template`, `xsl:with-param` |
-| 7 | Creating Result Tree | Supported | Literal result elements, attribute value templates |
-| 7.1.2 | Creating Elements | Supported | `xsl:element` with dynamic names/namespaces |
-| 7.1.3 | Creating Attributes | Supported | `xsl:attribute` with dynamic names/namespaces |
-| 7.2 | Creating Text | Supported | `xsl:value-of`, `xsl:text` |
-| 7.3 | Creating PIs | Supported | `xsl:processing-instruction` |
-| 7.4 | Creating Comments | Supported | `xsl:comment` |
-| 7.5 | Copying | Supported | `xsl:copy`, `xsl:copy-of` |
-| 7.6 | Attribute Sets | Supported | `xsl:attribute-set`, `use-attribute-sets` |
-| 7.6.2 | Namespace Aliases | Supported | `xsl:namespace-alias` |
-| 8 | Repetition | Supported | `xsl:for-each` |
-| 9 | Conditional Processing | Supported | `xsl:if`, `xsl:choose`, `xsl:when`, `xsl:otherwise` |
-| 10 | Sorting | Supported | `xsl:sort` with multiple keys, data-types, order |
-| 11 | Variables/Parameters | Supported | `xsl:variable`, `xsl:param`, scoping rules |
-| 11.1 | Result Tree Fragments | Supported | RTF handling as per spec |
-| 12 | Additional Functions | Supported | `document()`, `key()`, `format-number()`, `current()`, `generate-id()`, `system-property()` |
-| 12.3 | Number Formatting | Supported | `xsl:number` with all formatting options |
-| 13 | Messages | Supported | `xsl:message` with `terminate` attribute |
-| 14 | Extensions | Partial | `xsl:fallback` supported |
-| 15 | Fallback | Supported | `xsl:fallback` element |
-| 16 | Output | Supported | `xsl:output` with method, encoding, indent |
-
-### XPath 1.0 Specification Compliance
-
-| Section | Feature | Status | Notes |
-|---------|---------|--------|-------|
-| 2.1 | Location Steps | Supported | axis::node-test[predicate] |
-| 2.2 | Axes | Supported | All 13 axes implemented |
-| 2.3 | Node Tests | Supported | Name tests, `node()`, `text()`, `comment()`, `processing-instruction()` |
-| 2.4 | Predicates | Supported | Position and boolean predicates |
-| 2.5 | Abbreviated Syntax | Supported | `.`, `..`, `@`, `//` |
-| 3.1 | Basics | Supported | Expression evaluation |
-| 3.2 | Function Calls | Supported | All core functions |
-| 3.3 | Node-sets | Supported | Union operator `\|` |
-| 3.4 | Booleans | Supported | `and`, `or`, `not()` |
-| 3.5 | Numbers | Supported | IEEE 754 double-precision |
-| 3.6 | Strings | Supported | Unicode string handling |
-| 3.7 | Lexical Structure | Supported | Full tokenization |
-| 4.1 | Node Set Functions | Supported | `last()`, `position()`, `count()`, `id()`, `local-name()`, `namespace-uri()`, `name()` |
-| 4.2 | String Functions | Supported | `string()`, `concat()`, `starts-with()`, `contains()`, `substring-before()`, `substring-after()`, `substring()`, `string-length()`, `normalize-space()`, `translate()` |
-| 4.3 | Boolean Functions | Supported | `boolean()`, `not()`, `true()`, `false()`, `lang()` |
-| 4.4 | Number Functions | Supported | `number()`, `sum()`, `floor()`, `ceiling()`, `round()` |
-
-### XPath Axes Implementation
-
-| Axis | Status | Description |
-|------|--------|-------------|
-| `child` | Supported | Children of context node |
-| `descendant` | Supported | Descendants of context node |
-| `parent` | Supported | Parent of context node |
-| `ancestor` | Supported | Ancestors of context node |
-| `following-sibling` | Supported | Following siblings |
-| `preceding-sibling` | Supported | Preceding siblings |
-| `following` | Supported | Nodes after context in document order |
-| `preceding` | Supported | Nodes before context in document order |
-| `attribute` | Supported | Attributes of context node |
-| `namespace` | Supported | Namespace nodes |
-| `self` | Supported | Context node itself |
-| `descendant-or-self` | Supported | Context node and descendants |
-| `ancestor-or-self` | Supported | Context node and ancestors |
-
-### DOM Level 3 Core Compliance
-
-| Interface | Status | Notes |
-|-----------|--------|-------|
-| `Node` | Supported | All node type constants |
-| `Document` | Supported | `createElement`, `createTextNode`, `createComment`, etc. |
-| `Element` | Supported | `getAttribute`, `setAttribute`, namespace methods |
-| `Attr` | Supported | Attribute nodes with namespace support |
-| `Text` | Supported | Text node handling |
-| `Comment` | Supported | Comment nodes |
-| `ProcessingInstruction` | Supported | PI nodes with target and data |
-| `DocumentFragment` | Supported | Fragment handling in transforms |
-| `NamedNodeMap` | Supported | Attribute collections |
-| `NodeList` | Supported | Child node collections |
-
-### Web API Compliance
-
-This implementation provides full compatibility with the [MDN XSLTProcessor API](https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor):
-
-| Method | Status | Notes |
-|--------|--------|-------|
-| `importStylesheet(node)` | Supported | Accepts Document or Element |
-| `transformToFragment(source, output)` | Supported | Returns DocumentFragment |
-| `transformToDocument(source)` | Supported | Returns XMLDocument |
-| `setParameter(namespaceURI, localName, value)` | Supported | Full namespace support |
-| `getParameter(namespaceURI, localName)` | Supported | Returns parameter value |
-| `removeParameter(namespaceURI, localName)` | Supported | Removes single parameter |
-| `clearParameters()` | Supported | Removes all parameters |
-| `reset()` | Supported | Resets processor state |
-
-### Test Coverage by Specification
-
-| Specification | Tests | Coverage |
-|---------------|-------|----------|
-| XSLT 1.0 Elements | 82+ | 100% of supported elements |
-| XPath 1.0 Functions | 50+ | 100% of core functions |
-| XPath 1.0 Axes | 26+ | All 13 axes |
-| DOM Level 3 | 20+ | Core interfaces |
-| XSLTProcessor API | 39+ | All methods |
-| Security | 34+ | DoS prevention, prototype pollution |
-| **Total** | **441** | **99.41% line coverage** |
-
-## Style Guide
-
-### Colors
-
-| Usage | Color | Hex |
-|-------|-------|-----|
-| Primary | Blue | `#2563eb` |
-| Success | Green | `#16a34a` |
-| Warning | Amber | `#d97706` |
-| Error | Red | `#dc2626` |
-| Text | Gray | `#1f2937` |
-| Background | White | `#ffffff` |
-
-All colors meet WCAG 2.2 AA contrast requirements for accessibility.
+- [CONTRIBUTORS.md](CONTRIBUTORS.md) - how to contribute
+- [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md)
+- [SECURITY.md](SECURITY.md) - reporting vulnerabilities and the threat model
+- [CHANGELOG.md](CHANGELOG.md) - release history
 
 ## License