@ismail-elkorchi/css-parser 0.1.0 → 0.2.0

package/dist/internal/properties/registry.d.ts

@@ -0,0 +1,24 @@
+export interface CustomPropertySemantics {
+    readonly kind: "custom";
+    readonly name: string;
+}
+export interface StandardPropertySemantics {
+    readonly kind: "standard";
+    readonly requestedName: string;
+    readonly name: string;
+    readonly legacyAlias: boolean;
+    readonly syntax: string | null;
+    readonly styleDeclaration: readonly string[];
+    readonly longhands: readonly string[];
+    readonly resetLonghands: readonly string[];
+    readonly initial: string | null;
+    readonly appliesTo: string | null;
+    readonly inherited: string | null;
+    readonly percentages: string | null;
+    readonly computedValue: string | null;
+    readonly animationType: string | null;
+    readonly canonicalOrder: string | null;
+    readonly specRef: string;
+}
+export type CssPropertySemantics = CustomPropertySemantics | StandardPropertySemantics;
+export declare function resolveCssProperty(name: string): CssPropertySemantics | null;

package/dist/internal/properties/registry.js

@@ -0,0 +1,52 @@
+import { CSS_WEBREF_DATA } from "../generated/css-data.js";
+import { tokenizeCss } from "../syntax/tokenizer.js";
+const PROPERTY_DATA = new Map(CSS_WEBREF_DATA.properties.map((property) => [property.name, property]));
+function lowerAscii(value) {
+    return value.replace(/[A-Z]/gu, (character) => character.toLowerCase());
+}
+function freezeStrings(values) {
+    return Object.freeze([...(values ?? [])]);
+}
+function isCustomPropertyName(name) {
+    if (!name.startsWith("--") || name.length === 2)
+        return false;
+    const result = tokenizeCss(name);
+    return (result.errors.length === 0 &&
+        result.tokens.length === 1 &&
+        result.tokens[0]?.kind === "ident" &&
+        result.tokens[0].value === name);
+}
+function standardSemantics(requestedName, requested) {
+    const canonicalName = requested.legacyAliasOf ?? requested.name;
+    const canonical = PROPERTY_DATA.get(canonicalName);
+    if (canonical === undefined)
+        return null;
+    return Object.freeze({
+        kind: "standard",
+        requestedName,
+        name: canonical.name,
+        legacyAlias: canonical !== requested,
+        syntax: canonical.syntax ?? null,
+        styleDeclaration: freezeStrings(canonical.styleDeclaration),
+        longhands: freezeStrings(canonical.longhands),
+        resetLonghands: freezeStrings(canonical.resetLonghands),
+        initial: canonical.initial ?? null,
+        appliesTo: canonical.appliesTo ?? null,
+        inherited: canonical.inherited ?? null,
+        percentages: canonical.percentages ?? null,
+        computedValue: canonical.computedValue ?? null,
+        animationType: canonical.animationType ?? null,
+        canonicalOrder: canonical.canonicalOrder ?? null,
+        specRef: canonical.href
+    });
+}
+export function resolveCssProperty(name) {
+    if (isCustomPropertyName(name)) {
+        return Object.freeze({ kind: "custom", name });
+    }
+    const requestedName = lowerAscii(name);
+    const requested = PROPERTY_DATA.get(requestedName);
+    return requested === undefined
+        ? null
+        : standardSemantics(requestedName, requested);
+}

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

@@ -0,0 +1,96 @@
+import type { SelectorList, SelectorPseudoClass } from "./types.js";
+import type { SelectorResourceLimits, ResourceUsage, SourceSpan } from "../syntax/types.js";
+export type SelectorDecision = "match" | "no-match" | "unknown";
+export interface SelectorAttributeData {
+    readonly namespace: string | null;
+    readonly localName: string;
+    readonly value: string;
+}
+export interface SelectorElementData {
+    readonly kind: "element";
+    readonly namespace: string | null;
+    readonly localName: string;
+    readonly attributes: readonly SelectorAttributeData[];
+}
+export interface SelectorTextData {
+    readonly kind: "text";
+    readonly value: string;
+}
+export interface SelectorOtherNodeData {
+    readonly kind: "other";
+}
+export type SelectorNodeData = SelectorElementData | SelectorTextData | SelectorOtherNodeData;
+export interface SelectorTreeAdapter<TNode extends object> {
+    readonly data: (node: TNode) => SelectorNodeData;
+    readonly children: (node: TNode) => readonly TNode[];
+}
+export type SelectorNamespaceResolution = {
+    readonly status: "resolved";
+    readonly namespace: string | null;
+} | {
+    readonly status: "unknown";
+};
+export type SelectorDefaultNamespace = {
+    readonly kind: "any";
+} | {
+    readonly kind: "namespace";
+    readonly namespace: string | null;
+};
+export type SelectorDocumentMode = {
+    readonly syntax: "html";
+    readonly quirks: "no-quirks" | "limited-quirks" | "quirks";
+} | {
+    readonly syntax: "xml";
+};
+export interface SelectorPseudoContext<TNode extends object> {
+    readonly root: TNode;
+    readonly scopes: ReadonlySet<TNode>;
+}
+export interface SelectorEnvironment<TNode extends object> {
+    readonly tree: SelectorTreeAdapter<TNode>;
+    readonly documentMode: SelectorDocumentMode;
+    readonly defaultNamespace: SelectorDefaultNamespace;
+    readonly idValues: (node: TNode, element: SelectorElementData) => readonly string[];
+    readonly classNames: (node: TNode, element: SelectorElementData) => readonly string[];
+    readonly resolveNamespacePrefix: (prefix: string) => SelectorNamespaceResolution;
+    readonly attributeValueCaseSensitivity: (element: SelectorElementData, attribute: SelectorAttributeData) => "sensitive" | "ascii-insensitive";
+    readonly matchPseudoClass: (node: TNode, pseudo: SelectorPseudoClass, context: SelectorPseudoContext<TNode>) => SelectorDecision;
+}
+export interface SelectorMatchOptions<TNode extends object = object> {
+    readonly limits?: SelectorResourceLimits;
+    readonly signal?: AbortSignal;
+    readonly scopes?: ReadonlySet<TNode>;
+    readonly nesting?: SelectorList;
+}
+export interface SelectorUnknownReason {
+    readonly code: "namespace-prefix" | "pseudo-class";
+    readonly name: string;
+    readonly span: SourceSpan;
+}
+export type SelectorMatchResult = {
+    readonly status: "match";
+    readonly usage: ResourceUsage;
+} | {
+    readonly status: "no-match";
+    readonly usage: ResourceUsage;
+} | {
+    readonly status: "unknown";
+    readonly reasons: readonly SelectorUnknownReason[];
+    readonly usage: ResourceUsage;
+};
+export interface SelectorQueryUnknown<TNode extends object> {
+    readonly node: TNode;
+    readonly reasons: readonly SelectorUnknownReason[];
+}
+export interface SelectorQueryResult<TNode extends object> {
+    readonly matches: readonly TNode[];
+    readonly unknown: readonly SelectorQueryUnknown<TNode>[];
+    readonly usage: ResourceUsage;
+}
+export declare class SelectorTreeError extends TypeError {
+    readonly reason: "cycle" | "shared-node";
+    readonly code = "CSS_SELECTOR_INVALID_TREE";
+    constructor(reason: "cycle" | "shared-node");
+}
+export declare function matchSelectorList<TNode extends object>(selector: SelectorList, node: TNode, root: TNode, environment: SelectorEnvironment<TNode>, options?: SelectorMatchOptions<TNode>): SelectorMatchResult;
+export declare function querySelectorList<TNode extends object>(selector: SelectorList, root: TNode, environment: SelectorEnvironment<TNode>, options?: SelectorMatchOptions<TNode>): SelectorQueryResult<TNode>;