@ismail-elkorchi/css-parser 0.1.0 → 0.2.0

package/dist/internal/syntax/input.js

@@ -0,0 +1,184 @@
+import { ResourceGuard } from "./resources.js";
+const CARRIAGE_RETURN = 0x0d;
+const FORM_FEED = 0x0c;
+const LINE_FEED = 0x0a;
+const NULL = 0x00;
+const REPLACEMENT_CHARACTER = 0xfffd;
+export function utf8ByteLength(input) {
+    let bytes = 0;
+    for (let offset = 0; offset < input.length; offset += 1) {
+        const first = input.charCodeAt(offset);
+        if (first <= 0x7f) {
+            bytes += 1;
+        }
+        else if (first <= 0x7ff) {
+            bytes += 2;
+        }
+        else if (first >= 0xd800 && first <= 0xdbff) {
+            const second = input.charCodeAt(offset + 1);
+            if (second >= 0xdc00 && second <= 0xdfff) {
+                bytes += 4;
+                offset += 1;
+            }
+            else {
+                bytes += 3;
+            }
+        }
+        else {
+            bytes += 3;
+        }
+    }
+    return bytes;
+}
+function decodeAt(input, offset) {
+    if (offset >= input.length) {
+        return null;
+    }
+    const first = input.charCodeAt(offset);
+    if (first === CARRIAGE_RETURN) {
+        const following = input.charCodeAt(offset + 1);
+        return {
+            value: LINE_FEED,
+            endOffset: following === LINE_FEED ? offset + 2 : offset + 1
+        };
+    }
+    if (first === FORM_FEED) {
+        return { value: LINE_FEED, endOffset: offset + 1 };
+    }
+    if (first === NULL) {
+        return { value: REPLACEMENT_CHARACTER, endOffset: offset + 1 };
+    }
+    if (first >= 0xd800 && first <= 0xdbff) {
+        const second = input.charCodeAt(offset + 1);
+        if (second >= 0xdc00 && second <= 0xdfff) {
+            return {
+                value: ((first - 0xd800) * 0x400) + (second - 0xdc00) + 0x10000,
+                endOffset: offset + 2
+            };
+        }
+        return { value: REPLACEMENT_CHARACTER, endOffset: offset + 1 };
+    }
+    if (first >= 0xdc00 && first <= 0xdfff) {
+        return { value: REPLACEMENT_CHARACTER, endOffset: offset + 1 };
+    }
+    return { value: first, endOffset: offset + 1 };
+}
+export class InputCursor {
+    #input;
+    #guard;
+    #offset = 0;
+    #line = 1;
+    #column = 1;
+    #lastMark = null;
+    constructor(input, guard = new ResourceGuard()) {
+        this.#input = input;
+        this.#guard = guard;
+    }
+    get sourceLength() {
+        return this.#input.length;
+    }
+    get offset() {
+        return this.#offset;
+    }
+    get eof() {
+        return this.#offset >= this.#input.length;
+    }
+    position() {
+        return Object.freeze({
+            offset: this.#offset,
+            line: this.#line,
+            column: this.#column
+        });
+    }
+    mark() {
+        return Object.freeze({
+            offset: this.#offset,
+            line: this.#line,
+            column: this.#column
+        });
+    }
+    restore(mark) {
+        if (!Number.isSafeInteger(mark.offset) ||
+            mark.offset < 0 ||
+            mark.offset > this.#input.length ||
+            !Number.isSafeInteger(mark.line) ||
+            mark.line < 1 ||
+            !Number.isSafeInteger(mark.column) ||
+            mark.column < 1) {
+            throw new RangeError("invalid input cursor mark");
+        }
+        this.#offset = mark.offset;
+        this.#line = mark.line;
+        this.#column = mark.column;
+        this.#lastMark = null;
+    }
+    peek(distance = 0) {
+        if (!Number.isSafeInteger(distance) || distance < 0) {
+            throw new RangeError("peek distance must be a non-negative safe integer");
+        }
+        this.#guard.step();
+        let offset = this.#offset;
+        let decoded = null;
+        for (let index = 0; index <= distance; index += 1) {
+            decoded = decodeAt(this.#input, offset);
+            if (decoded === null) {
+                return null;
+            }
+            offset = decoded.endOffset;
+        }
+        return decoded?.value ?? null;
+    }
+    consume() {
+        this.#guard.step();
+        const decoded = decodeAt(this.#input, this.#offset);
+        if (decoded === null) {
+            this.#lastMark = null;
+            return null;
+        }
+        const start = this.position();
+        this.#lastMark = this.mark();
+        this.#offset = decoded.endOffset;
+        if (decoded.value === LINE_FEED) {
+            this.#line += 1;
+            this.#column = 1;
+        }
+        else {
+            this.#column += 1;
+        }
+        return Object.freeze({
+            value: decoded.value,
+            span: Object.freeze({
+                start,
+                end: this.position()
+            })
+        });
+    }
+    reconsume() {
+        if (this.#lastMark === null) {
+            throw new Error("no consumed code point is available to reconsume");
+        }
+        const mark = this.#lastMark;
+        this.restore(mark);
+    }
+    slice(start, end) {
+        if (!Number.isSafeInteger(start) ||
+            !Number.isSafeInteger(end) ||
+            start < 0 ||
+            end < start ||
+            end > this.#input.length) {
+            throw new RangeError("invalid source slice");
+        }
+        return this.#input.slice(start, end);
+    }
+}
+export function preprocessCssInput(input, guard = new ResourceGuard()) {
+    const cursor = new InputCursor(input, guard);
+    let result = "";
+    for (;;) {
+        const point = cursor.consume();
+        if (point === null) {
+            return result;
+        }
+        result += String.fromCodePoint(point.value);
+    }
+}

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

@@ -0,0 +1,26 @@
+import type { CommaSeparatedComponentValuesResult, ComponentValue, ComponentValuesResult, CssBlockItem, CssDeclaration, CssRule, CssStylesheet, SyntaxResult } from "./ast.js";
+import type { ParserResourceLimits } from "./types.js";
+export interface SyntaxParserOptions {
+    readonly limits?: ParserResourceLimits;
+    readonly signal?: AbortSignal;
+}
+export declare class CssSyntaxParser {
+    #private;
+    constructor(input: string, options?: SyntaxParserOptions);
+    parseStylesheet(): SyntaxResult<CssStylesheet>;
+    parseStylesheetContents(): SyntaxResult<readonly CssRule[]>;
+    parseBlockContents(): SyntaxResult<readonly CssBlockItem[]>;
+    parseRule(): SyntaxResult<CssRule>;
+    parseDeclaration(): SyntaxResult<CssDeclaration>;
+    parseComponentValue(): SyntaxResult<ComponentValue>;
+    parseComponentValues(): ComponentValuesResult;
+    parseCommaSeparatedComponentValues(): CommaSeparatedComponentValuesResult;
+}
+export declare function parseCssStylesheet(input: string, options?: SyntaxParserOptions): SyntaxResult<CssStylesheet>;
+export declare function parseCssStylesheetContents(input: string, options?: SyntaxParserOptions): SyntaxResult<readonly CssRule[]>;
+export declare function parseCssBlockContents(input: string, options?: SyntaxParserOptions): SyntaxResult<readonly CssBlockItem[]>;
+export declare function parseCssRule(input: string, options?: SyntaxParserOptions): SyntaxResult<CssRule>;
+export declare function parseCssDeclaration(input: string, options?: SyntaxParserOptions): SyntaxResult<CssDeclaration>;
+export declare function parseCssComponentValue(input: string, options?: SyntaxParserOptions): SyntaxResult<ComponentValue>;
+export declare function parseCssComponentValues(input: string, options?: SyntaxParserOptions): ComponentValuesResult;
+export declare function parseCssCommaSeparatedComponentValues(input: string, options?: SyntaxParserOptions): CommaSeparatedComponentValuesResult;