@ismail-elkorchi/css-parser 0.1.0 → 0.2.0

package/dist/internal/syntax/tokens.d.ts

@@ -0,0 +1,115 @@
+import type { ResourceUsage, SourcePosition, SourceSpan } from "./types.js";
+interface TokenBase {
+    readonly span: SourceSpan;
+}
+export interface IdentToken extends TokenBase {
+    readonly kind: "ident";
+    readonly value: string;
+}
+export interface FunctionToken extends TokenBase {
+    readonly kind: "function";
+    readonly value: string;
+}
+export interface AtKeywordToken extends TokenBase {
+    readonly kind: "at-keyword";
+    readonly value: string;
+}
+export interface HashToken extends TokenBase {
+    readonly kind: "hash";
+    readonly value: string;
+    readonly hashType: "id" | "unrestricted";
+}
+export interface StringToken extends TokenBase {
+    readonly kind: "string";
+    readonly value: string;
+}
+export interface BadStringToken extends TokenBase {
+    readonly kind: "bad-string";
+}
+export interface UrlToken extends TokenBase {
+    readonly kind: "url";
+    readonly value: string;
+}
+export interface BadUrlToken extends TokenBase {
+    readonly kind: "bad-url";
+}
+export interface DelimToken extends TokenBase {
+    readonly kind: "delim";
+    readonly value: number;
+}
+export interface NumericValue {
+    readonly value: number;
+    readonly numberType: "integer" | "number";
+    readonly representation: string;
+    readonly sign: "+" | "-" | null;
+}
+export interface NumberToken extends TokenBase, NumericValue {
+    readonly kind: "number";
+}
+export interface PercentageToken extends TokenBase, NumericValue {
+    readonly kind: "percentage";
+}
+export interface DimensionToken extends TokenBase, NumericValue {
+    readonly kind: "dimension";
+    readonly unit: string;
+}
+export interface UnicodeRangeToken extends TokenBase {
+    readonly kind: "unicode-range";
+    readonly start: number;
+    readonly end: number;
+}
+export interface WhitespaceToken extends TokenBase {
+    readonly kind: "whitespace";
+}
+export interface CdoToken extends TokenBase {
+    readonly kind: "cdo";
+}
+export interface CdcToken extends TokenBase {
+    readonly kind: "cdc";
+}
+export interface ColonToken extends TokenBase {
+    readonly kind: "colon";
+}
+export interface SemicolonToken extends TokenBase {
+    readonly kind: "semicolon";
+}
+export interface CommaToken extends TokenBase {
+    readonly kind: "comma";
+}
+export interface OpenSquareToken extends TokenBase {
+    readonly kind: "open-square";
+}
+export interface CloseSquareToken extends TokenBase {
+    readonly kind: "close-square";
+}
+export interface OpenParenToken extends TokenBase {
+    readonly kind: "open-paren";
+}
+export interface CloseParenToken extends TokenBase {
+    readonly kind: "close-paren";
+}
+export interface OpenCurlyToken extends TokenBase {
+    readonly kind: "open-curly";
+}
+export interface CloseCurlyToken extends TokenBase {
+    readonly kind: "close-curly";
+}
+export interface EofToken extends TokenBase {
+    readonly kind: "eof";
+}
+export type CssToken = IdentToken | FunctionToken | AtKeywordToken | HashToken | StringToken | BadStringToken | UrlToken | BadUrlToken | DelimToken | NumberToken | PercentageToken | DimensionToken | UnicodeRangeToken | WhitespaceToken | CdoToken | CdcToken | ColonToken | SemicolonToken | CommaToken | OpenSquareToken | CloseSquareToken | OpenParenToken | CloseParenToken | OpenCurlyToken | CloseCurlyToken | EofToken;
+export type TokenizerDiagnosticCode = "unexpected-eof-in-comment" | "unexpected-eof-in-string" | "newline-in-string" | "unexpected-eof-in-escape" | "invalid-escape" | "unexpected-eof-in-url" | "invalid-url";
+export interface TokenizerDiagnostic {
+    readonly kind: "tokenizer";
+    readonly code: TokenizerDiagnosticCode;
+    readonly message: string;
+    readonly span: SourceSpan;
+    readonly specRef: string;
+}
+export interface TokenizationResult {
+    readonly tokens: readonly Exclude<CssToken, EofToken>[];
+    readonly errors: readonly TokenizerDiagnostic[];
+    readonly end: SourcePosition;
+    readonly usage: ResourceUsage;
+}
+export {};

package/dist/internal/syntax/tokens.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/syntax/types.d.ts

@@ -0,0 +1,46 @@
+export interface SourcePosition {
+    readonly offset: number;
+    readonly line: number;
+    readonly column: number;
+}
+export interface SourceSpan {
+    readonly start: SourcePosition;
+    readonly end: SourcePosition;
+}
+export interface InputCodePoint {
+    readonly value: number;
+    readonly span: SourceSpan;
+}
+export type ResourceLimitName = "maxInputBytes" | "maxBufferedBytes" | "maxTokens" | "maxNodes" | "maxDepth" | "maxSteps";
+export interface ResourceLimits {
+    readonly maxInputBytes?: number;
+    readonly maxBufferedBytes?: number;
+    readonly maxTokens?: number;
+    readonly maxNodes?: number;
+    readonly maxDepth?: number;
+    readonly maxSteps?: number;
+}
+export type TokenizerResourceLimits = Pick<ResourceLimits, "maxInputBytes" | "maxTokens" | "maxSteps">;
+export type ParserResourceLimits = Pick<ResourceLimits, "maxInputBytes" | "maxTokens" | "maxNodes" | "maxDepth" | "maxSteps">;
+export type StreamTokenizerResourceLimits = TokenizerResourceLimits & Pick<ResourceLimits, "maxBufferedBytes">;
+export type StreamParserResourceLimits = ParserResourceLimits & Pick<ResourceLimits, "maxBufferedBytes">;
+export type SelectorResourceLimits = Pick<ResourceLimits, "maxNodes" | "maxDepth" | "maxSteps">;
+export interface ResourceUsage {
+    readonly inputBytes: number;
+    readonly maxBufferedBytes: number;
+    readonly tokens: number;
+    readonly nodes: number;
+    readonly maxDepth: number;
+    readonly steps: number;
+}
+export interface EncodingOptions {
+    readonly transportEncodingLabel?: string;
+    readonly environmentEncodingLabel?: string;
+    readonly defaultEncodingLabel?: string;
+    readonly maxCharsetBytes?: number;
+}
+export interface EncodingDecision {
+    readonly encoding: string;
+    readonly source: "bom" | "transport" | "charset" | "environment" | "default";
+    readonly bomBytes: number;
+}

package/dist/internal/syntax/types.js

@@ -0,0 +1 @@
+export {};

package/dist/mod.d.ts

@@ -1 +1,7 @@
-export { applyPatchPlan, BudgetExceededError, chunk, compileSelectorList, computePatch, extractInlineRenderSignals, extractInlineStyleSignals, extractRenderSignals, extractStyleRuleSignals, findAllByType, findById, getParseErrorSpecRef, matchesSelector, outline, parse, parseBytes, parseDeclarationList, parseFragment, parseRuleList, parseStream, PatchPlanningError, querySelectorAll, serialize, tokenize, tokenizeStream, walk, walkByType, type BudgetOptions, type Chunk, type ChunkOptions, type CssNode, type Edit, type FragmentTree, type NodeId, type NodeVisitor, type Outline, type OutlineEntry, type ParseContext, type ParseError, type ParseOptions, type PatchInsertStep, type PatchPlan, type PatchPlanningErrorPayload, type PatchSliceStep, type PatchStep, type SelectorCombinator, type SelectorNodeLike, type SelectorQueryOptions, type SelectorSimple, type RenderSignal, type RenderSignalClass, type RenderSignalOptions, type StyleDeclarationSignal, type StyleRuleSignal, type StyleSignalOptions, type StyleSignalSpecificity, type SelectorUnsupportedPart, type CompiledSelectorCompound, type CompiledSelector, type CompiledSelectorList, type Span, type StartEndToken, type StyleSheetTree, type Token, type TokenizeOptions, type TraceEvent } from "./public/mod.js";
+/**
+ * Standards-based CSS parsing, serialization, traversal, editing, property,
+ * declaration-block, and selector APIs.
+ *
+ * @module
+ */
+export * from "./public/mod.js";

package/dist/mod.js

@@ -1 +1,7 @@
-export { applyPatchPlan, BudgetExceededError, chunk, compileSelectorList, computePatch, extractInlineRenderSignals, extractInlineStyleSignals, extractRenderSignals, extractStyleRuleSignals, findAllByType, findById, getParseErrorSpecRef, matchesSelector, outline, parse, parseBytes, parseDeclarationList, parseFragment, parseRuleList, parseStream, PatchPlanningError, querySelectorAll, serialize, tokenize, tokenizeStream, walk, walkByType } from "./public/mod.js";
+/**
+ * Standards-based CSS parsing, serialization, traversal, editing, property,
+ * declaration-block, and selector APIs.
+ *
+ * @module
+ */
+export * from "./public/mod.js";

package/dist/public/edits.d.ts

@@ -0,0 +1,12 @@
+import type { CssStylesheet } from "../internal/syntax/ast.js";
+import type { CssSourceEdit, PatchPlan, PatchPlanningErrorCode } from "./types.js";
+export declare class PatchPlanningError extends Error {
+    readonly reason: PatchPlanningErrorCode;
+    readonly target?: number | undefined;
+    readonly code = "CSS_PATCH_PLANNING_FAILED";
+    constructor(reason: PatchPlanningErrorCode, target?: number | undefined);
+}
+/** Builds a deterministic source-preserving edit plan against a parsed tree. */
+export declare function computePatch(source: string, stylesheet: CssStylesheet, edits: readonly CssSourceEdit[]): PatchPlan;
+/** Applies a validated CSS source patch. */
+export declare function applyPatch(source: string, plan: PatchPlan): string;

package/dist/public/edits.js

@@ -0,0 +1,195 @@
+import { walkCss } from "./traversal.js";
+export class PatchPlanningError extends Error {
+    reason;
+    target;
+    code = "CSS_PATCH_PLANNING_FAILED";
+    constructor(reason, target) {
+        super(`Unable to plan CSS source edits: ${reason}` +
+            (target === undefined ? "" : ` (node ${String(target)})`));
+        this.reason = reason;
+        this.target = target;
+        this.name = "PatchPlanningError";
+    }
+}
+function indexNodes(root) {
+    const nodes = new Map();
+    walkCss(root, (node) => {
+        if (nodes.has(node.id)) {
+            throw new PatchPlanningError("duplicate-node-id", node.id);
+        }
+        nodes.set(node.id, node);
+    });
+    return nodes;
+}
+function editRecord(value, order) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new PatchPlanningError("invalid-edit", order);
+    }
+    return value;
+}
+function validatedEdit(value, order) {
+    const edit = editRecord(value, order);
+    const target = edit.target;
+    if (!Number.isSafeInteger(target) || target <= 0) {
+        throw new PatchPlanningError("invalid-edit", order);
+    }
+    const kind = edit.kind;
+    if (kind === "remove-node") {
+        return { kind, target: target };
+    }
+    if (kind === "replace-node" ||
+        kind === "insert-before" ||
+        kind === "insert-after") {
+        if (typeof edit.css !== "string") {
+            throw new PatchPlanningError("invalid-edit", target);
+        }
+        return {
+            kind,
+            target: target,
+            css: edit.css
+        };
+    }
+    throw new PatchPlanningError("invalid-edit", target);
+}
+function replacementFor(source, nodes, edit, order) {
+    const node = nodes.get(edit.target);
+    if (node === undefined) {
+        throw new PatchPlanningError("node-not-found", edit.target);
+    }
+    const { start, end } = node.span;
+    if (start.offset < 0 ||
+        end.offset < start.offset ||
+        end.offset > source.length) {
+        throw new PatchPlanningError("span-out-of-bounds", edit.target);
+    }
+    switch (edit.kind) {
+        case "remove-node":
+            return { order, target: edit.target, start: start.offset, end: end.offset, text: "" };
+        case "replace-node":
+            return {
+                order,
+                target: edit.target,
+                start: start.offset,
+                end: end.offset,
+                text: edit.css
+            };
+        case "insert-before":
+            return {
+                order,
+                target: edit.target,
+                start: start.offset,
+                end: start.offset,
+                text: edit.css
+            };
+        case "insert-after":
+            return {
+                order,
+                target: edit.target,
+                start: end.offset,
+                end: end.offset,
+                text: edit.css
+            };
+    }
+}
+/** Builds a deterministic source-preserving edit plan against a parsed tree. */
+export function computePatch(source, stylesheet, edits) {
+    if (typeof source !== "string")
+        throw new TypeError("source must be a string");
+    if (!Array.isArray(edits)) {
+        throw new PatchPlanningError("invalid-edit");
+    }
+    const nodes = indexNodes(stylesheet);
+    const replacements = edits.map((edit, order) => replacementFor(source, nodes, validatedEdit(edit, order), order)).sort((left, right) => left.start - right.start ||
+        left.end - right.end ||
+        left.order - right.order);
+    let coveredUntil = 0;
+    for (const replacement of replacements) {
+        if (replacement.start < coveredUntil) {
+            throw new PatchPlanningError("overlapping-edits", replacement.target);
+        }
+        coveredUntil = Math.max(coveredUntil, replacement.end);
+    }
+    const operations = [];
+    let cursor = 0;
+    for (const replacement of replacements) {
+        if (cursor < replacement.start) {
+            operations.push({
+                kind: "copy",
+                start: cursor,
+                end: replacement.start
+            });
+        }
+        operations.push({
+            kind: "replace",
+            start: replacement.start,
+            end: replacement.end,
+            text: replacement.text
+        });
+        cursor = replacement.end;
+    }
+    if (cursor < source.length) {
+        operations.push({ kind: "copy", start: cursor, end: source.length });
+    }
+    const frozenOperations = Object.freeze(operations);
+    const plan = Object.freeze({
+        operations: frozenOperations,
+        result: applyOperations(source, frozenOperations)
+    });
+    return plan;
+}
+function applyOperations(source, operations) {
+    let cursor = 0;
+    let result = "";
+    for (const value of operations) {
+        if (value === null || typeof value !== "object" || Array.isArray(value)) {
+            throw new PatchPlanningError("invalid-plan");
+        }
+        const operation = value;
+        if (operation.kind === "copy") {
+            if (operation.start !== cursor ||
+                !Number.isSafeInteger(operation.end) ||
+                operation.end < cursor ||
+                operation.end > source.length) {
+                throw new PatchPlanningError("invalid-plan");
+            }
+            result += source.slice(cursor, operation.end);
+            cursor = operation.end;
+        }
+        else if (operation.kind === "replace") {
+            if (operation.start !== cursor ||
+                !Number.isSafeInteger(operation.end) ||
+                operation.end < cursor ||
+                operation.end > source.length ||
+                typeof operation.text !== "string") {
+                throw new PatchPlanningError("invalid-plan");
+            }
+            result += operation.text;
+            cursor = operation.end;
+        }
+        else {
+            throw new PatchPlanningError("invalid-plan");
+        }
+    }
+    if (cursor !== source.length) {
+        throw new PatchPlanningError("invalid-plan");
+    }
+    return result;
+}
+/** Applies a validated CSS source patch. */
+export function applyPatch(source, plan) {
+    if (typeof source !== "string")
+        throw new TypeError("source must be a string");
+    const input = plan;
+    if (input === null || typeof input !== "object" || Array.isArray(input)) {
+        throw new PatchPlanningError("invalid-plan");
+    }
+    const record = input;
+    if (!Array.isArray(record.operations) || typeof record.result !== "string") {
+        throw new PatchPlanningError("invalid-plan");
+    }
+    const result = applyOperations(source, record.operations);
+    if (result !== record.result) {
+        throw new PatchPlanningError("invalid-plan");
+    }
+    return result;
+}

package/dist/public/mod.d.ts

@@ -1,35 +1,13 @@
-import type { BudgetExceededPayload, CompiledSelectorList, Chunk, ChunkOptions, CssNode, Edit, FragmentTree, NodeId, NodeVisitor, Outline, ParseOptions, PatchPlan, PatchPlanningErrorPayload, SelectorNodeLike, SelectorQueryOptions, RenderSignal, RenderSignalOptions, StyleDeclarationSignal, StyleRuleSignal, StyleSignalOptions, StyleSheetTree, Token, TokenizeOptions } from "./types.js";
-export type { BudgetExceededPayload, BudgetOptions, CompiledSelector, CompiledSelectorCompound, CompiledSelectorList, Chunk, ChunkOptions, CssNode, Edit, FragmentTree, NodeId, NodeVisitor, Outline, OutlineEntry, ParseContext, ParseError, ParseOptions, PatchInsertStep, PatchPlan, PatchPlanningErrorPayload, PatchSliceStep, PatchStep, Span, SpanProvenance, SelectorCombinator, SelectorNodeLike, SelectorQueryOptions, SelectorSimple, SelectorUnsupportedPart, RenderSignal, RenderSignalClass, RenderSignalOptions, StyleDeclarationSignal, StyleRuleSignal, StyleSignalOptions, StyleSignalSpecificity, StartEndToken, StyleSheetTree, Token, TokenizeOptions, TraceEvent } from "./types.js";
-export declare class BudgetExceededError extends Error {
-    readonly payload: BudgetExceededPayload;
-    constructor(payload: BudgetExceededPayload);
-}
-export declare class PatchPlanningError extends Error {
-    readonly payload: PatchPlanningErrorPayload;
-    constructor(payload: PatchPlanningErrorPayload);
-}
-export declare function parse(css: string, options?: ParseOptions): StyleSheetTree;
-export declare function parseFragment(css: string, contextTagName: string, options?: ParseOptions): FragmentTree;
-export declare function parseRuleList(css: string, options?: ParseOptions): FragmentTree;
-export declare function parseDeclarationList(css: string, options?: ParseOptions): FragmentTree;
-export declare function getParseErrorSpecRef(parseErrorId: string): string;
-export declare function tokenize(css: string, options?: TokenizeOptions): readonly Token[];
-export declare function tokenizeStream(stream: ReadableStream<Uint8Array>, options?: TokenizeOptions): AsyncIterable<Token>;
-export declare function parseBytes(bytes: Uint8Array, options?: ParseOptions): StyleSheetTree;
-export declare function parseStream(stream: ReadableStream<Uint8Array>, options?: ParseOptions): Promise<StyleSheetTree>;
-export declare function serialize(treeOrNode: StyleSheetTree | FragmentTree | CssNode): string;
-export declare function walk(tree: StyleSheetTree | FragmentTree, visitor: NodeVisitor): void;
-export declare function walkByType(tree: StyleSheetTree | FragmentTree, type: string, visitor: NodeVisitor): void;
-export declare function findById(tree: StyleSheetTree | FragmentTree, id: NodeId): CssNode | null;
-export declare function findAllByType(tree: StyleSheetTree | FragmentTree, type: string): IterableIterator<CssNode>;
-export declare function outline(tree: StyleSheetTree | FragmentTree): Outline;
-export declare function chunk(tree: StyleSheetTree | FragmentTree, options?: ChunkOptions): Chunk[];
-export declare function applyPatchPlan(originalCss: string, plan: PatchPlan): string;
-export declare function computePatch(originalCss: string, edits: readonly Edit[]): PatchPlan;
-export declare function compileSelectorList(selectorText: string): CompiledSelectorList;
-export declare function extractStyleRuleSignals(cssOrTree: string | StyleSheetTree, options?: StyleSignalOptions): readonly StyleRuleSignal[];
-export declare function extractInlineStyleSignals(styleText: string): readonly StyleDeclarationSignal[];
-export declare function extractRenderSignals(cssOrTree: string | StyleSheetTree, options?: RenderSignalOptions): readonly RenderSignal[];
-export declare function extractInlineRenderSignals(styleText: string, options?: RenderSignalOptions): readonly RenderSignal[];
-export declare function matchesSelector<TNode extends SelectorNodeLike>(selector: string | CompiledSelectorList, node: TNode, root: TNode, options?: SelectorQueryOptions): boolean;
-export declare function querySelectorAll<TNode extends SelectorNodeLike>(selector: string | CompiledSelectorList, root: TNode, options?: SelectorQueryOptions): readonly TNode[];
+export { CssStreamError, parseBlockContents, parseCommaSeparatedComponentValues, parseComponentValue, parseComponentValues, parseDeclaration, parseRule, parseStylesheet, parseStylesheetBytes, parseStylesheetContents, parseStylesheetStream, tokenize, tokenizeBytes, tokenizeStream } from "./parse.js";
+export { CssTreeStructureError, findNodeById, findNodesByKind, walkCss } from "./traversal.js";
+export { applyPatch, computePatch, PatchPlanningError } from "./edits.js";
+export { serializeCssSyntax as serialize, serializeCssComponentValues } from "../internal/syntax/serialize.js";
+export { CssSerializationError } from "../internal/syntax/serialize.js";
+export { SyntaxAbortError, SyntaxResourceError } from "../internal/syntax/resources.js";
+export { CssDeclarationBlock } from "../internal/cssom/declarations.js";
+export { resolveCssProperty } from "../internal/properties/registry.js";
+export { validateCssPropertyValue } from "../internal/properties/matcher.js";
+export { parseSelectorList } from "../internal/selectors/parser.js";
+export { specificitiesOfSelectorList, specificityOfComplexSelector } from "../internal/selectors/specificity.js";
+export { matchSelectorList, querySelectorList, SelectorTreeError } from "../internal/selectors/matcher.js";
+export type * from "./types.js";