@ismail-elkorchi/css-parser 0.1.1 → 0.2.0

package/dist/internal/selectors/specificity.js

@@ -0,0 +1,77 @@
+const ZERO = Object.freeze({ a: 0, b: 0, c: 0 });
+function add(left, right) {
+    return Object.freeze({
+        a: left.a + right.a,
+        b: left.b + right.b,
+        c: left.c + right.c
+    });
+}
+function compare(left, right) {
+    return left.a - right.a || left.b - right.b || left.c - right.c;
+}
+function maximum(selectors, options) {
+    let best = ZERO;
+    for (const selector of selectors) {
+        const candidate = specificityOfComplexSelector(selector, options);
+        if (compare(candidate, best) > 0)
+            best = candidate;
+    }
+    return best;
+}
+function pseudoClassSpecificity(pseudo, options) {
+    if (pseudo.name === "where" &&
+        pseudo.argument.kind === "selector-list") {
+        return ZERO;
+    }
+    if ((pseudo.name === "is" ||
+        pseudo.name === "not" ||
+        pseudo.name === "has") &&
+        pseudo.argument.kind === "selector-list") {
+        return maximum(pseudo.argument.selectors, options);
+    }
+    const own = Object.freeze({ a: 0, b: 1, c: 0 });
+    if ((pseudo.name === "nth-child" ||
+        pseudo.name === "nth-last-child") &&
+        pseudo.argument.kind === "nth") {
+        return add(own, maximum(pseudo.argument.of, options));
+    }
+    return own;
+}
+function pseudoElementSpecificity(pseudo, options) {
+    const own = Object.freeze({ a: 0, b: 0, c: 1 });
+    if (pseudo.name === "slotted" &&
+        pseudo.argument.kind === "selector-list") {
+        return add(own, maximum(pseudo.argument.selectors, options));
+    }
+    return own;
+}
+function simpleSpecificity(simple, options) {
+    switch (simple.kind) {
+        case "id":
+            return Object.freeze({ a: 1, b: 0, c: 0 });
+        case "class":
+        case "attribute":
+            return Object.freeze({ a: 0, b: 1, c: 0 });
+        case "pseudo-class":
+            return pseudoClassSpecificity(simple, options);
+        case "pseudo-element":
+            return pseudoElementSpecificity(simple, options);
+        case "nesting":
+            return options.nesting ?? ZERO;
+    }
+}
+export function specificityOfComplexSelector(selector, options = {}) {
+    let result = ZERO;
+    for (const compound of selector.compounds) {
+        if (compound.type !== null && !compound.type.universal) {
+            result = add(result, Object.freeze({ a: 0, b: 0, c: 1 }));
+        }
+        for (const simple of compound.simples) {
+            result = add(result, simpleSpecificity(simple, options));
+        }
+    }
+    return result;
+}
+export function specificitiesOfSelectorList(list, options = {}) {
+    return Object.freeze(list.selectors.map((selector) => specificityOfComplexSelector(selector, options)));
+}

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

@@ -0,0 +1,110 @@
+import type { ComponentValue, SyntaxDiagnostic } from "../syntax/ast.js";
+import type { ParserResourceLimits, ResourceUsage, SourceSpan } from "../syntax/types.js";
+export type SelectorCombinator = " " | ">" | "+" | "~";
+export interface SelectorType {
+    readonly kind: "type";
+    readonly namespace: string | null;
+    readonly name: string;
+    readonly universal: boolean;
+    readonly span: SourceSpan;
+}
+export interface SelectorId {
+    readonly kind: "id";
+    readonly value: string;
+    readonly span: SourceSpan;
+}
+export interface SelectorClass {
+    readonly kind: "class";
+    readonly value: string;
+    readonly span: SourceSpan;
+}
+export type SelectorAttributeMatcher = "=" | "~=" | "|=" | "^=" | "$=" | "*=";
+export interface SelectorAttribute {
+    readonly kind: "attribute";
+    readonly namespace: string | null;
+    readonly name: string;
+    readonly matcher: SelectorAttributeMatcher | null;
+    readonly value: string | null;
+    readonly modifier: "i" | "s" | null;
+    readonly span: SourceSpan;
+}
+export type SelectorPseudoArgument = {
+    readonly kind: "none";
+} | {
+    readonly kind: "raw";
+    readonly value: readonly ComponentValue[];
+} | {
+    readonly kind: "selector-list";
+    readonly selectors: readonly ComplexSelector[];
+    readonly forgiving: boolean;
+    readonly relative: boolean;
+} | {
+    readonly kind: "nth";
+    readonly a: number;
+    readonly b: number;
+    readonly of: readonly ComplexSelector[];
+};
+export interface SelectorPseudoClass {
+    readonly kind: "pseudo-class";
+    readonly name: string;
+    readonly argument: SelectorPseudoArgument;
+    readonly span: SourceSpan;
+}
+export interface SelectorPseudoElement {
+    readonly kind: "pseudo-element";
+    readonly name: string;
+    readonly argument: SelectorPseudoArgument;
+    readonly span: SourceSpan;
+}
+export interface SelectorNesting {
+    readonly kind: "nesting";
+    readonly span: SourceSpan;
+}
+export type SimpleSelector = SelectorId | SelectorClass | SelectorAttribute | SelectorPseudoClass | SelectorPseudoElement | SelectorNesting;
+export interface CompoundSelector {
+    readonly type: SelectorType | null;
+    readonly simples: readonly SimpleSelector[];
+    readonly span: SourceSpan;
+}
+export interface ComplexSelector {
+    readonly leadingCombinator: SelectorCombinator | null;
+    readonly compounds: readonly CompoundSelector[];
+    readonly combinators: readonly SelectorCombinator[];
+    readonly span: SourceSpan;
+}
+export interface SelectorList {
+    readonly selectors: readonly ComplexSelector[];
+    readonly span: SourceSpan;
+}
+export type SelectorDiagnosticCode = "empty-selector" | "invalid-selector" | "invalid-combinator" | "invalid-attribute" | "invalid-pseudo" | "invalid-nth";
+export interface SelectorDiagnostic {
+    readonly kind: "selector";
+    readonly code: SelectorDiagnosticCode;
+    readonly message: string;
+    readonly span: SourceSpan;
+    readonly specRef: string;
+}
+export interface SelectorParseSuccess {
+    readonly ok: true;
+    readonly value: SelectorList;
+    readonly errors: readonly (SyntaxDiagnostic | SelectorDiagnostic)[];
+    readonly usage: ResourceUsage;
+}
+export interface SelectorParseFailure {
+    readonly ok: false;
+    readonly errors: readonly (SyntaxDiagnostic | SelectorDiagnostic)[];
+    readonly usage: ResourceUsage;
+}
+export type SelectorParseResult = SelectorParseSuccess | SelectorParseFailure;
+export interface SelectorParserOptions {
+    readonly limits?: ParserResourceLimits;
+    readonly signal?: AbortSignal;
+}
+export interface SelectorSpecificity {
+    readonly a: number;
+    readonly b: number;
+    readonly c: number;
+}
+export interface SelectorSpecificityOptions {
+    readonly nesting?: SelectorSpecificity;
+}

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

@@ -0,0 +1,70 @@
+import type { AtKeywordToken, BadStringToken, BadUrlToken, CdcToken, CdoToken, CloseCurlyToken, CloseParenToken, CloseSquareToken, ColonToken, CommaToken, DelimToken, DimensionToken, HashToken, IdentToken, NumberToken, PercentageToken, SemicolonToken, StringToken, TokenizerDiagnostic, UnicodeRangeToken, UrlToken, WhitespaceToken } from "./tokens.js";
+import type { ResourceUsage, SourceSpan } from "./types.js";
+interface SyntaxNodeBase {
+    readonly id: number;
+    readonly span: SourceSpan;
+}
+export type PreservedToken = IdentToken | AtKeywordToken | HashToken | StringToken | BadStringToken | UrlToken | BadUrlToken | DelimToken | NumberToken | PercentageToken | DimensionToken | UnicodeRangeToken | WhitespaceToken | CdoToken | CdcToken | ColonToken | SemicolonToken | CommaToken | CloseSquareToken | CloseParenToken | CloseCurlyToken;
+export interface CssFunction extends SyntaxNodeBase {
+    readonly kind: "function-block";
+    readonly name: string;
+    readonly value: readonly ComponentValue[];
+}
+export interface CssSimpleBlock extends SyntaxNodeBase {
+    readonly kind: "simple-block";
+    readonly associatedToken: "open-square" | "open-paren" | "open-curly";
+    readonly value: readonly ComponentValue[];
+}
+export type ComponentValue = PreservedToken | CssFunction | CssSimpleBlock;
+export interface CssDeclaration extends SyntaxNodeBase {
+    readonly kind: "declaration";
+    readonly name: string;
+    readonly value: readonly ComponentValue[];
+    readonly important: boolean;
+    readonly originalText?: string;
+}
+export interface CssAtRule extends SyntaxNodeBase {
+    readonly kind: "at-rule";
+    readonly name: string;
+    readonly prelude: readonly ComponentValue[];
+    readonly block: CssBlock | null;
+}
+export interface CssQualifiedRule extends SyntaxNodeBase {
+    readonly kind: "qualified-rule";
+    readonly prelude: readonly ComponentValue[];
+    readonly block: CssBlock;
+}
+export type CssRule = CssAtRule | CssQualifiedRule;
+export type CssBlockItem = CssDeclaration | CssRule;
+export interface CssBlock extends SyntaxNodeBase {
+    readonly kind: "block";
+    readonly items: readonly CssBlockItem[];
+}
+export interface CssStylesheet extends SyntaxNodeBase {
+    readonly kind: "stylesheet";
+    readonly rules: readonly CssRule[];
+}
+export type ParserDiagnosticCode = "empty-input" | "trailing-input" | "invalid-rule" | "invalid-declaration" | "unexpected-closing-token" | "bad-string-token" | "bad-url-token";
+export interface ParserDiagnostic {
+    readonly kind: "parser";
+    readonly code: ParserDiagnosticCode;
+    readonly message: string;
+    readonly span: SourceSpan;
+    readonly specRef: string;
+}
+export type SyntaxDiagnostic = TokenizerDiagnostic | ParserDiagnostic;
+interface SyntaxResultBase {
+    readonly errors: readonly SyntaxDiagnostic[];
+    readonly usage: ResourceUsage;
+}
+export interface SyntaxSuccess<T> extends SyntaxResultBase {
+    readonly ok: true;
+    readonly value: T;
+}
+export interface SyntaxFailure extends SyntaxResultBase {
+    readonly ok: false;
+}
+export type SyntaxResult<T> = SyntaxSuccess<T> | SyntaxFailure;
+export type ComponentValuesResult = SyntaxResult<readonly ComponentValue[]>;
+export type CommaSeparatedComponentValuesResult = SyntaxResult<readonly (readonly ComponentValue[])[]>;
+export {};

package/dist/internal/syntax/ast.js

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

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

@@ -0,0 +1,8 @@
+export declare function isWhitespace(value: number | null): boolean;
+export declare function isDigit(value: number | null): boolean;
+export declare function isHexDigit(value: number | null): boolean;
+export declare function isAsciiLetter(value: number | null): boolean;
+export declare function isNonAsciiIdent(value: number | null): boolean;
+export declare function isIdentStart(value: number | null): boolean;
+export declare function isIdent(value: number | null): boolean;
+export declare function isNonPrintable(value: number | null): boolean;

package/dist/internal/syntax/characters.js

@@ -0,0 +1,45 @@
+export function isWhitespace(value) {
+    return value === 0x09 || value === 0x0a || value === 0x20;
+}
+export function isDigit(value) {
+    return value !== null && value >= 0x30 && value <= 0x39;
+}
+export function isHexDigit(value) {
+    return (isDigit(value) ||
+        (value !== null && value >= 0x41 && value <= 0x46) ||
+        (value !== null && value >= 0x61 && value <= 0x66));
+}
+export function isAsciiLetter(value) {
+    return ((value !== null && value >= 0x41 && value <= 0x5a) ||
+        (value !== null && value >= 0x61 && value <= 0x7a));
+}
+export function isNonAsciiIdent(value) {
+    return (value === 0x00b7 ||
+        (value !== null && value >= 0x00c0 && value <= 0x00d6) ||
+        (value !== null && value >= 0x00d8 && value <= 0x00f6) ||
+        (value !== null && value >= 0x00f8 && value <= 0x037d) ||
+        (value !== null && value >= 0x037f && value <= 0x1fff) ||
+        value === 0x200c ||
+        value === 0x200d ||
+        value === 0x203f ||
+        value === 0x2040 ||
+        (value !== null && value >= 0x2070 && value <= 0x218f) ||
+        (value !== null && value >= 0x2c00 && value <= 0x2fef) ||
+        (value !== null && value >= 0x3001 && value <= 0xd7ff) ||
+        (value !== null && value >= 0xf900 && value <= 0xfdcf) ||
+        (value !== null && value >= 0xfdf0 && value <= 0xfffd) ||
+        (value !== null && value >= 0x10000));
+}
+export function isIdentStart(value) {
+    return value === 0x5f || isAsciiLetter(value) || isNonAsciiIdent(value);
+}
+export function isIdent(value) {
+    return isIdentStart(value) || isDigit(value) || value === 0x2d;
+}
+export function isNonPrintable(value) {
+    return (value !== null &&
+        ((value >= 0x00 && value <= 0x08) ||
+            value === 0x0b ||
+            (value >= 0x0e && value <= 0x1f) ||
+            value === 0x7f));
+}

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

@@ -0,0 +1,15 @@
+import type { EncodingDecision, EncodingOptions } from "./types.js";
+export declare function canonicalizeEncodingLabel(label: string): string | null;
+export declare function sniffCssEncoding(bytes: Uint8Array, options?: EncodingOptions): EncodingDecision;
+export declare function decodeCssBytes(bytes: Uint8Array, options?: EncodingOptions): {
+    readonly text: string;
+    readonly decision: EncodingDecision;
+};
+export declare class CssEncodingSniffer {
+    #private;
+    constructor(options?: EncodingOptions);
+    get bufferedBytes(): number;
+    get decision(): EncodingDecision | null;
+    write(chunk: Uint8Array): EncodingDecision | null;
+    finish(): EncodingDecision;
+}

package/dist/internal/syntax/encoding.js

@@ -0,0 +1,161 @@
+const DEFAULT_MAX_CHARSET_BYTES = 1024;
+const CHARSET_PREFIX = Uint8Array.from([
+    0x40, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x20, 0x22
+]);
+function detectBom(bytes, final) {
+    if (bytes.length >= 3 && bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+        return { encoding: "utf-8", bytes: 3 };
+    }
+    if (bytes.length >= 2 && bytes[0] === 0xfe && bytes[1] === 0xff) {
+        return { encoding: "utf-16be", bytes: 2 };
+    }
+    if (bytes.length >= 2 && bytes[0] === 0xff && bytes[1] === 0xfe) {
+        return { encoding: "utf-16le", bytes: 2 };
+    }
+    if (!final &&
+        (bytes.length === 0 ||
+            (bytes.length === 1 && (bytes[0] === 0xef || bytes[0] === 0xfe || bytes[0] === 0xff)) ||
+            (bytes.length === 2 && bytes[0] === 0xef && bytes[1] === 0xbb))) {
+        return undefined;
+    }
+    return null;
+}
+export function canonicalizeEncodingLabel(label) {
+    const normalized = label.trim().toLowerCase();
+    if (normalized.length === 0) {
+        return null;
+    }
+    try {
+        return new TextDecoder(normalized).encoding.toLowerCase();
+    }
+    catch {
+        return null;
+    }
+}
+function normalizedCharsetEncoding(label) {
+    const encoding = canonicalizeEncodingLabel(label);
+    if (encoding === "utf-16be" || encoding === "utf-16le") {
+        return "utf-8";
+    }
+    return encoding;
+}
+function scanCharset(bytes, final, maximum) {
+    const length = Math.min(bytes.length, maximum);
+    for (let index = 0; index < Math.min(length, CHARSET_PREFIX.length); index += 1) {
+        if (bytes[index] !== CHARSET_PREFIX[index]) {
+            return { kind: "absent" };
+        }
+    }
+    if (length < CHARSET_PREFIX.length) {
+        return final || length >= maximum ? { kind: "absent" } : { kind: "pending" };
+    }
+    let label = "";
+    for (let index = CHARSET_PREFIX.length; index < length; index += 1) {
+        const byte = bytes[index];
+        if (byte === 0x22) {
+            if (index + 1 >= length) {
+                return final || length >= maximum ? { kind: "absent" } : { kind: "pending" };
+            }
+            if (bytes[index + 1] !== 0x3b) {
+                return { kind: "absent" };
+            }
+            const encoding = normalizedCharsetEncoding(label);
+            return encoding === null ? { kind: "absent" } : { kind: "encoding", encoding };
+        }
+        if (byte === undefined || byte > 0x7f) {
+            return { kind: "absent" };
+        }
+        label += String.fromCharCode(byte);
+    }
+    return final || length >= maximum ? { kind: "absent" } : { kind: "pending" };
+}
+function normalizedMaximum(options) {
+    const value = options.maxCharsetBytes ?? DEFAULT_MAX_CHARSET_BYTES;
+    if (!Number.isSafeInteger(value) || value < CHARSET_PREFIX.length + 2) {
+        throw new RangeError(`maxCharsetBytes must be a safe integer of at least ${String(CHARSET_PREFIX.length + 2)}`);
+    }
+    return value;
+}
+function fallbackDecision(options) {
+    const environment = options.environmentEncodingLabel === undefined
+        ? null
+        : canonicalizeEncodingLabel(options.environmentEncodingLabel);
+    if (environment !== null) {
+        return { encoding: environment, source: "environment", bomBytes: 0 };
+    }
+    const fallback = options.defaultEncodingLabel === undefined
+        ? "utf-8"
+        : canonicalizeEncodingLabel(options.defaultEncodingLabel);
+    return {
+        encoding: fallback ?? "utf-8",
+        source: "default",
+        bomBytes: 0
+    };
+}
+function decide(bytes, options, final) {
+    const bom = detectBom(bytes, final);
+    if (bom === undefined) {
+        return null;
+    }
+    if (bom !== null) {
+        return { encoding: bom.encoding, source: "bom", bomBytes: bom.bytes };
+    }
+    if (options.transportEncodingLabel !== undefined) {
+        const transport = canonicalizeEncodingLabel(options.transportEncodingLabel);
+        if (transport !== null) {
+            return { encoding: transport, source: "transport", bomBytes: 0 };
+        }
+    }
+    const maximum = normalizedMaximum(options);
+    const charset = scanCharset(bytes, final, maximum);
+    if (charset.kind === "pending") {
+        return null;
+    }
+    if (charset.kind === "encoding") {
+        return { encoding: charset.encoding, source: "charset", bomBytes: 0 };
+    }
+    return fallbackDecision(options);
+}
+export function sniffCssEncoding(bytes, options = {}) {
+    return decide(bytes, options, true) ?? fallbackDecision(options);
+}
+export function decodeCssBytes(bytes, options = {}) {
+    const decision = sniffCssEncoding(bytes, options);
+    const decoder = new TextDecoder(decision.encoding);
+    return Object.freeze({
+        text: decoder.decode(bytes),
+        decision
+    });
+}
+export class CssEncodingSniffer {
+    #options;
+    #buffer;
+    #length = 0;
+    #decision = null;
+    constructor(options = {}) {
+        const maximum = normalizedMaximum(options);
+        this.#options = Object.freeze({ ...options, maxCharsetBytes: maximum });
+        this.#buffer = new Uint8Array(maximum);
+    }
+    get bufferedBytes() {
+        return this.#length;
+    }
+    get decision() {
+        return this.#decision;
+    }
+    write(chunk) {
+        if (this.#decision !== null) {
+            return this.#decision;
+        }
+        const available = this.#buffer.length - this.#length;
+        const consumed = Math.min(available, chunk.byteLength);
+        this.#buffer.set(chunk.subarray(0, consumed), this.#length);
+        this.#length += consumed;
+        this.#decision = decide(this.#buffer.subarray(0, this.#length), this.#options, false);
+        return this.#decision;
+    }
+    finish() {
+        this.#decision ??= decide(this.#buffer.subarray(0, this.#length), this.#options, true) ?? fallbackDecision(this.#options);
+        return this.#decision;
+    }
+}

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

@@ -0,0 +1,23 @@
+import { ResourceGuard } from "./resources.js";
+import type { InputCodePoint, SourcePosition } from "./types.js";
+export interface InputCursorMark {
+    readonly offset: number;
+    readonly line: number;
+    readonly column: number;
+}
+export declare function utf8ByteLength(input: string): number;
+export declare class InputCursor {
+    #private;
+    constructor(input: string, guard?: ResourceGuard);
+    get sourceLength(): number;
+    get offset(): number;
+    get eof(): boolean;
+    position(): SourcePosition;
+    mark(): InputCursorMark;
+    restore(mark: InputCursorMark): void;
+    peek(distance?: number): number | null;
+    consume(): InputCodePoint | null;
+    reconsume(): void;
+    slice(start: number, end: number): string;
+}
+export declare function preprocessCssInput(input: string, guard?: ResourceGuard): string;