@ismail-elkorchi/css-parser 0.1.0 → 0.2.0

package/dist/internal/syntax/resources.js

@@ -0,0 +1,135 @@
+const LIMIT_NAMES = [
+    "maxInputBytes",
+    "maxBufferedBytes",
+    "maxTokens",
+    "maxNodes",
+    "maxDepth",
+    "maxSteps"
+];
+export class SyntaxResourceError extends Error {
+    limitName;
+    limit;
+    actual;
+    code = "CSS_RESOURCE_LIMIT_EXCEEDED";
+    constructor(limitName, limit, actual) {
+        super(`${limitName} exceeded: limit ${String(limit)}, observed ${String(actual)}`);
+        this.limitName = limitName;
+        this.limit = limit;
+        this.actual = actual;
+        this.name = "SyntaxResourceError";
+    }
+}
+export class SyntaxAbortError extends Error {
+    reason;
+    code = "CSS_OPERATION_ABORTED";
+    constructor(reason) {
+        super("CSS operation aborted", reason === undefined ? undefined : { cause: reason });
+        this.reason = reason;
+        this.name = "SyntaxAbortError";
+    }
+}
+function validateLimit(name, value) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError(`${name} must be a non-negative safe integer`);
+    }
+}
+export class ResourceGuard {
+    signal;
+    limits;
+    #inputBytes = 0;
+    #maxBufferedBytes = 0;
+    #tokens = 0;
+    #nodes = 0;
+    #maxDepth = 0;
+    #steps = 0;
+    constructor(limits = {}, signal, initialUsage) {
+        this.signal = signal;
+        for (const name of LIMIT_NAMES) {
+            validateLimit(name, limits[name]);
+        }
+        this.limits = Object.freeze({ ...limits });
+        if (initialUsage !== undefined) {
+            this.assertObservedValue(initialUsage.inputBytes, "inputBytes");
+            this.assertObservedValue(initialUsage.maxBufferedBytes, "maxBufferedBytes");
+            this.assertObservedValue(initialUsage.tokens, "tokens");
+            this.assertObservedValue(initialUsage.nodes, "nodes");
+            this.assertObservedValue(initialUsage.maxDepth, "maxDepth");
+            this.assertObservedValue(initialUsage.steps, "steps");
+            this.#inputBytes = initialUsage.inputBytes;
+            this.#maxBufferedBytes = initialUsage.maxBufferedBytes;
+            this.#tokens = initialUsage.tokens;
+            this.#nodes = initialUsage.nodes;
+            this.#maxDepth = initialUsage.maxDepth;
+            this.#steps = initialUsage.steps;
+            this.#enforce("maxInputBytes", this.#inputBytes);
+            this.#enforce("maxBufferedBytes", this.#maxBufferedBytes);
+            this.#enforce("maxTokens", this.#tokens);
+            this.#enforce("maxNodes", this.#nodes);
+            this.#enforce("maxDepth", this.#maxDepth);
+            this.#enforce("maxSteps", this.#steps);
+        }
+        this.assertActive();
+    }
+    assertActive() {
+        if (this.signal?.aborted === true) {
+            throw new SyntaxAbortError(this.signal.reason);
+        }
+    }
+    setInputBytes(value) {
+        this.assertObservedValue(value, "inputBytes");
+        this.#inputBytes = Math.max(this.#inputBytes, value);
+        this.#enforce("maxInputBytes", value);
+    }
+    observeBufferedBytes(value) {
+        this.assertObservedValue(value, "bufferedBytes");
+        this.#maxBufferedBytes = Math.max(this.#maxBufferedBytes, value);
+        this.#enforce("maxBufferedBytes", value);
+    }
+    emitToken(count = 1) {
+        this.assertIncrement(count);
+        this.#tokens += count;
+        this.#enforce("maxTokens", this.#tokens);
+    }
+    createNode(depth) {
+        this.assertObservedValue(depth, "depth");
+        this.#nodes += 1;
+        this.#maxDepth = Math.max(this.#maxDepth, depth);
+        this.#enforce("maxNodes", this.#nodes);
+        this.#enforce("maxDepth", depth);
+    }
+    step(count = 1) {
+        this.assertIncrement(count);
+        this.#steps += count;
+        this.#enforce("maxSteps", this.#steps);
+        this.assertActive();
+    }
+    snapshot() {
+        return Object.freeze({
+            inputBytes: this.#inputBytes,
+            maxBufferedBytes: this.#maxBufferedBytes,
+            tokens: this.#tokens,
+            nodes: this.#nodes,
+            maxDepth: this.#maxDepth,
+            steps: this.#steps
+        });
+    }
+    #enforce(name, actual) {
+        const limit = this.limits[name];
+        if (limit !== undefined && actual > limit) {
+            throw new SyntaxResourceError(name, limit, actual);
+        }
+    }
+    assertIncrement(value) {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            throw new RangeError("resource increments must be positive safe integers");
+        }
+    }
+    assertObservedValue(value, name) {
+        if (!Number.isSafeInteger(value) || value < 0) {
+            throw new RangeError(`${name} must be a non-negative safe integer`);
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { ComponentValue, CssBlock, CssDeclaration, CssRule, CssStylesheet } from "./ast.js";
+export type CssSyntaxSerializable = CssStylesheet | CssRule | CssBlock | CssDeclaration | ComponentValue;
+export type CssSerializationErrorCode = "invalid-structure" | "cyclic-structure" | "shared-structure" | "duplicate-node-id" | "unserializable-token";
+export declare class CssSerializationError extends TypeError {
+    readonly code: CssSerializationErrorCode;
+    readonly path: string;
+    constructor(code: CssSerializationErrorCode, path: string, message: string);
+}
+export declare function serializeCssSyntax(value: CssSyntaxSerializable): string;
+export declare function serializeCssComponentValues(values: readonly ComponentValue[]): string;