@ismail-elkorchi/css-parser 0.1.0 → 0.2.0

package/README.md

@@ -1,100 +1,98 @@
 # @ismail-elkorchi/css-parser
 
-Deterministic CSS parsing and selector evaluation for automation pipelines that need stable output across Node, Deno, Bun, and modern browsers.
+A CSS syntax parser, serializer, CSSOM declaration model, property validator,
+and Selectors Level 4 engine for Node.js, Deno, Bun, and modern browsers. It has
+no runtime dependencies.
 
 ## Install
 
-```bash
+```sh
 npm install @ismail-elkorchi/css-parser
 ```
 
-```bash
+```sh
 deno add jsr:@ismail-elkorchi/css-parser
 ```
 
-```txt
-import { parse } from "jsr:@ismail-elkorchi/css-parser";
-```
-
-## Success Path
+## Parse and serialize CSS
 
 ```ts
-import {
-  compileSelectorList,
-  parse,
-  parseStream,
-  querySelectorAll,
-  serialize
-} from "@ismail-elkorchi/css-parser";
-
-const css = ".card { color: red; } #content .card { margin: 1px; }";
-const parsed = parse(css, {
-  budgets: { maxInputBytes: 4096, maxNodes: 256, maxDepth: 32 }
-});
-
-const stream = new ReadableStream({
-  start(controller) {
-    controller.enqueue(new TextEncoder().encode(".a{display:block}"));
-    controller.close();
-  }
-});
-
-const streamed = await parseStream(stream, {
-  budgets: { maxInputBytes: 4096, maxBufferedBytes: 256, maxNodes: 256 }
-});
+import { parseStylesheet, serialize } from "@ismail-elkorchi/css-parser";
 
-const selector = compileSelectorList("#content .card");
-const root = {
-  kind: "document",
-  children: [{ kind: "element", tagName: "main", attributes: [{ name: "id", value: "content" }], children: [] }]
-};
+const result = parseStylesheet(".card { color: red; margin: 1rem; }");
+if (!result.ok) {
+  throw new Error(result.errors.map((error) => error.message).join("\n"));
+}
 
-console.log(querySelectorAll(selector, root).length);
-console.log(serialize(parsed));
-console.log(serialize(streamed));
+console.log(serialize(result.value));
 ```
 
-Runnable examples:
+Parse results are discriminated by `ok`. Successful results contain `value`,
+recoverable `errors`, and measured `usage`. Resource or abort limits throw
+`SyntaxResourceError` or `SyntaxAbortError`.
 
-```bash
-npm run examples:run
-```
-
-## Options / API Reference
-
-- [Options and API reference](./docs/reference/options.md)
-
-## When To Use
+The package provides the CSS Syntax parsing entrypoints for stylesheets,
+stylesheet contents, block contents, rules, declarations, component values, and
+comma-separated component values. See the [API guide](./docs/api.md) for their
+exact names and result types.
 
-- You need deterministic CSS parse/serialize behavior for repeatable tooling.
-- You need parse budgets to bound runtime work and memory growth.
-- You need selector matching utilities in the same package as parsing.
+## Parse bytes and streams
 
-## When Not To Use
+`parseStylesheetBytes()` and `parseStylesheetStream()` apply the CSS encoding
+detection order and include the selected encoding in their result.
 
-- You need a browser layout engine.
-- You need CSS sanitization or policy enforcement beyond parsing.
-- You need runtime execution of scripts or DOM behavior.
+```ts
+import { parseStylesheetStream } from "@ismail-elkorchi/css-parser";
+
+const response = await fetch("https://example.test/site.css");
+if (response.body === null) throw new Error("Response has no body");
+
+const result = await parseStylesheetStream(response.body, {
+  limits: {
+    maxInputBytes: 1_000_000,
+    maxBufferedBytes: 64_000,
+    maxTokens: 100_000,
+    maxNodes: 50_000,
+    maxDepth: 128,
+    maxSteps: 1_000_000
+  }
+});
+```
 
-## Security Note
+Stream decoding is incremental; tree construction starts after the decoded
+stylesheet reaches EOF. `tokenizeBytes()` and `tokenizeStream()` expose the same
+encoding and resource accounting for tokenization.
 
-Use explicit budgets for untrusted input and fail closed on `BudgetExceededError`. Parsing validates syntax structure, not trust or safety policy. See [SECURITY.md](./SECURITY.md).
+## CSSOM declarations and selectors
 
-## Runtime Compatibility
+`CssDeclarationBlock` implements declaration parsing, priority, property-name,
+mutation, and serialization semantics. `resolveCssProperty()` and
+`validateCssPropertyValue()` use pinned WebRef grammar data.
 
-- Node.js (current LTS and current stable)
-- Deno (stable)
-- Bun (stable)
-- Modern evergreen browsers (smoke-tested)
+`matchSelectorList()` and `querySelectorList()` require an explicit typed
+environment for tree access, namespaces, document mode, attributes, and dynamic
+pseudo-classes. Their results preserve `match`, `no-match`, and `unknown`
+outcomes instead of guessing. See [Selector matching](./docs/selectors.md).
 
-## No Runtime Dependencies
+## Traversal and source edits
 
-No runtime dependencies are used by production parser code.
+`walkCss()`, `findNodeById()`, and `findNodesByKind()` operate on the typed
+structural syntax tree. `computePatch()` plans source-preserving remove, replace,
+and boundary insert edits against node spans; `applyPatch()` verifies and
+applies the resulting plan.
 
-## Docs Map
+Parsing and serialization are structural operations. They do not sanitize CSS,
+resolve the cascade, or perform layout.
 
-- [Documentation index](./docs/index.md)
+## Project information
 
-## Release Trigger
+- [API guide](./docs/api.md)
+- [Selector matching](./docs/selectors.md)
+- [Runnable examples](./examples/)
+- [Development](./docs/development.md)
+- [Security policy](./SECURITY.md)
+- [Changelog](./CHANGELOG.md)
 
-See [RELEASING.md](./RELEASING.md) for required secrets, trigger methods, and post-publish checks.
+Node.js 20, 22, and 24 are tested. Cross-runtime qualification covers Node.js,
+Deno, Bun, and Chromium. Release qualification also compares CSSOM
+serialization with Chromium, Firefox, and WebKit.

package/dist/internal/cssom/declarations.d.ts

@@ -0,0 +1,36 @@
+import type { PropertyValidationOptions } from "../properties/matcher.js";
+import type { SyntaxParserOptions } from "../syntax/parser.js";
+export interface CssDeclarationBlockOptions {
+    readonly parser?: SyntaxParserOptions;
+    readonly validation?: PropertyValidationOptions;
+}
+export interface CssomDeclaration {
+    readonly name: string;
+    readonly value: string;
+    readonly important: boolean;
+}
+export type CssDeclarationMutation = {
+    readonly status: "set";
+    readonly declaration: CssomDeclaration;
+    readonly previousValue: string;
+} | {
+    readonly status: "removed";
+    readonly previousValue: string;
+} | {
+    readonly status: "ignored";
+    readonly reason: "invalid-priority" | "unknown-property" | "invalid-value";
+};
+export declare class CssDeclarationBlock {
+    #private;
+    private constructor();
+    static parse(input: string, options?: CssDeclarationBlockOptions): CssDeclarationBlock;
+    static empty(options?: CssDeclarationBlockOptions): CssDeclarationBlock;
+    get length(): number;
+    get declarations(): readonly CssomDeclaration[];
+    get cssText(): string;
+    item(index: number): string;
+    getPropertyValue(name: string): string;
+    getPropertyPriority(name: string): "" | "important";
+    setProperty(name: string, value: string, priority?: string): CssDeclarationMutation;
+    removeProperty(name: string): string;
+}

package/dist/internal/cssom/declarations.js

@@ -0,0 +1,177 @@
+import { validateCssPropertyValue } from "../properties/matcher.js";
+import { resolveCssProperty } from "../properties/registry.js";
+import { parseCssBlockContents, parseCssDeclaration } from "../syntax/parser.js";
+import { serializeCssSyntax } from "../syntax/serialize.js";
+function lowerAscii(value) {
+    return value.replace(/[A-Z]/gu, (character) => character.toLowerCase());
+}
+function propertyIdentity(name) {
+    const property = resolveCssProperty(name);
+    if (property === null)
+        return null;
+    if (property.kind === "custom") {
+        return Object.freeze({ key: property.name, name: property.name });
+    }
+    return Object.freeze({
+        key: lowerAscii(property.name),
+        name: property.name
+    });
+}
+function significant(values) {
+    return values.filter((value) => value.kind !== "whitespace");
+}
+function serializeCssomValue(declaration) {
+    if (declaration.name.startsWith("--")) {
+        return declaration.originalText ?? "";
+    }
+    let result = "";
+    for (const value of significant(declaration.value)) {
+        const serialized = serializeCssSyntax(value);
+        if (value.kind === "comma") {
+            result = result.trimEnd();
+            result += ",";
+        }
+        else {
+            if (result.length > 0)
+                result += " ";
+            result += serialized;
+        }
+    }
+    return result.trim();
+}
+function normalizedDeclaration(declaration, options) {
+    const validation = validateCssPropertyValue(declaration, options.validation);
+    if (validation.status === "invalid")
+        return null;
+    const identity = propertyIdentity(declaration.name);
+    if (identity === null)
+        return null;
+    return Object.freeze({
+        key: identity.key,
+        declaration: Object.freeze({
+            name: identity.name,
+            value: serializeCssomValue(declaration),
+            important: declaration.important
+        })
+    });
+}
+function parseMutationDeclaration(name, value, important, options) {
+    const source = `${name}:${value}${important ? "!important" : ""}`;
+    const result = parseCssDeclaration(source, options.parser);
+    return result.ok ? normalizedDeclaration(result.value, options) : null;
+}
+function priorityStatus(priority) {
+    const normalized = lowerAscii(priority.trim());
+    if (normalized === "")
+        return false;
+    if (normalized === "important")
+        return true;
+    return null;
+}
+export class CssDeclarationBlock {
+    #options;
+    #entries = new Map();
+    constructor(options) {
+        this.#options = options;
+    }
+    static parse(input, options = {}) {
+        const block = new CssDeclarationBlock(options);
+        const parsed = parseCssBlockContents(input, options.parser);
+        if (!parsed.ok)
+            return block;
+        for (const item of parsed.value) {
+            if (item.kind !== "declaration")
+                continue;
+            const normalized = normalizedDeclaration(item, options);
+            if (normalized === null)
+                continue;
+            block.#setNormalized(normalized);
+        }
+        return block;
+    }
+    static empty(options = {}) {
+        return new CssDeclarationBlock(options);
+    }
+    get length() {
+        return this.#entries.size;
+    }
+    get declarations() {
+        return Object.freeze([...this.#entries.values()]);
+    }
+    get cssText() {
+        return [...this.#entries.values()]
+            .map((declaration) => `${declaration.name}: ${declaration.value}` +
+            `${declaration.important ? " !important" : ""};`)
+            .join(" ");
+    }
+    item(index) {
+        if (!Number.isInteger(index) || index < 0)
+            return "";
+        return [...this.#entries.values()][index]?.name ?? "";
+    }
+    getPropertyValue(name) {
+        const identity = propertyIdentity(name);
+        return identity === null
+            ? ""
+            : this.#entries.get(identity.key)?.value ?? "";
+    }
+    getPropertyPriority(name) {
+        const identity = propertyIdentity(name);
+        return identity !== null && this.#entries.get(identity.key)?.important === true
+            ? "important"
+            : "";
+    }
+    setProperty(name, value, priority = "") {
+        const important = priorityStatus(priority);
+        if (important === null) {
+            return Object.freeze({
+                status: "ignored",
+                reason: "invalid-priority"
+            });
+        }
+        if (value.length === 0) {
+            const previousValue = this.removeProperty(name);
+            return Object.freeze({
+                status: "removed",
+                previousValue
+            });
+        }
+        const identity = propertyIdentity(name);
+        if (identity === null) {
+            return Object.freeze({
+                status: "ignored",
+                reason: "unknown-property"
+            });
+        }
+        const normalized = parseMutationDeclaration(name, value, important, this.#options);
+        if (normalized === null) {
+            return Object.freeze({
+                status: "ignored",
+                reason: "invalid-value"
+            });
+        }
+        const previousValue = this.#entries.get(identity.key)?.value ?? "";
+        this.#entries.set(normalized.key, normalized.declaration);
+        return Object.freeze({
+            status: "set",
+            declaration: normalized.declaration,
+            previousValue
+        });
+    }
+    removeProperty(name) {
+        const identity = propertyIdentity(name);
+        if (identity === null)
+            return "";
+        const previous = this.#entries.get(identity.key);
+        this.#entries.delete(identity.key);
+        return previous?.value ?? "";
+    }
+    #setNormalized(normalized) {
+        const previous = this.#entries.get(normalized.key);
+        if (previous?.important === true &&
+            !normalized.declaration.important) {
+            return;
+        }
+        this.#entries.set(normalized.key, normalized.declaration);
+    }
+}

package/dist/internal/generated/css-data.d.ts

@@ -0,0 +1,2 @@
+import type { CssWebrefData } from "../grammar/catalog-types.js";
+export declare const CSS_WEBREF_DATA: CssWebrefData;