@tbela99/css-parser 0.0.1-alpha3

package/dist/index.d.ts

@@ -0,0 +1,329 @@
+interface LiteralToken {
+    typ: 'Literal';
+    val: string;
+}
+interface IdentToken {
+    typ: 'Iden';
+    val: string;
+}
+interface CommaToken {
+    typ: 'Comma';
+}
+interface ColonToken {
+    typ: 'Colon';
+}
+interface SemiColonToken {
+    typ: 'Semi-colon';
+}
+interface NumberToken {
+    typ: 'Number';
+    val: string;
+}
+interface AtRuleToken {
+    typ: 'At-rule';
+    val: string;
+}
+interface PercentageToken {
+    typ: 'Perc';
+    val: string;
+}
+interface FunctionToken {
+    typ: 'Func';
+    val: string;
+    chi: Token[];
+}
+interface FunctionURLToken {
+    typ: 'UrlFunc';
+    val: 'url';
+    chi: Array<UrlToken | CommentToken>;
+}
+interface StringToken {
+    typ: 'String';
+    val: string;
+}
+interface BadStringToken {
+    typ: 'Bad-string';
+    val: string;
+}
+interface UnclosedStringToken {
+    typ: 'Unclosed-string';
+    val: string;
+}
+interface DimensionToken {
+    typ: 'Dimension';
+    val: string;
+    unit: string;
+}
+interface LengthToken {
+    typ: 'Length';
+    val: string;
+    unit: string;
+}
+interface AngleToken {
+    typ: 'Angle';
+    val: string;
+    unit: string;
+}
+interface TimeToken {
+    typ: 'Time';
+    val: string;
+    unit: 'ms' | 's';
+}
+interface FrequencyToken {
+    typ: 'Frequency';
+    val: string;
+    unit: 'Hz' | 'Khz';
+}
+interface ResolutionToken {
+    typ: 'Resolution';
+    val: string;
+    unit: 'dpi' | 'dpcm' | 'dppx' | 'x';
+}
+interface HashToken {
+    typ: 'Hash';
+    val: string;
+}
+interface BlockStartToken {
+    typ: 'Block-start';
+}
+interface BlockEndToken {
+    typ: 'Block-end';
+}
+interface AttrStartToken {
+    typ: 'Attr-start';
+}
+interface AttrEndToken {
+    typ: 'Attr-end';
+}
+interface ParensStartToken {
+    typ: 'Start-parens';
+}
+interface ParensEndToken {
+    typ: 'End-parens';
+}
+interface WhitespaceToken {
+    typ: 'Whitespace';
+}
+interface CommentToken {
+    typ: 'Comment';
+    val: string;
+}
+interface BadCommentToken {
+    typ: 'Bad-comment';
+    val: string;
+}
+interface CDOCommentToken {
+    typ: 'CDOCOMM';
+    val: string;
+}
+interface BadCDOCommentToken {
+    typ: 'BADCDO';
+    val: string;
+}
+interface IncludesToken {
+    typ: 'Includes';
+    val: '~=';
+}
+interface DashMatchToken {
+    typ: 'Dash-match';
+    val: '|=';
+}
+interface LessThanToken {
+    typ: 'Lt';
+}
+interface GreaterThanToken {
+    typ: 'Gt';
+}
+interface PseudoClassToken {
+    typ: 'Pseudo-class';
+    val: string;
+}
+interface PseudoClassFunctionToken {
+    typ: 'Pseudo-class-func';
+    val: string;
+    chi: Token[];
+}
+interface DelimToken {
+    typ: 'Delim';
+    val: '=';
+}
+interface BadUrlToken {
+    typ: 'Bad-url-token';
+    val: string;
+}
+interface UrlToken {
+    typ: 'Url-token';
+    val: string;
+}
+interface EOFToken {
+    typ: 'EOF';
+}
+interface ImportantToken {
+    typ: 'Important';
+}
+interface ColorToken {
+    typ: 'Color';
+    val: string;
+    kin: 'lit' | 'hex' | 'rgb' | 'rgba' | 'hsl' | 'hsla' | 'hwb' | 'device-cmyk';
+    chi?: Token[];
+}
+interface AttrToken {
+    typ: 'Attr';
+    chi: Token[];
+}
+declare type Token = LiteralToken | IdentToken | CommaToken | ColonToken | SemiColonToken | NumberToken | AtRuleToken | PercentageToken | FunctionURLToken | FunctionToken | DimensionToken | LengthToken | AngleToken | StringToken | TimeToken | FrequencyToken | ResolutionToken | UnclosedStringToken | HashToken | BadStringToken | BlockStartToken | BlockEndToken | AttrStartToken | AttrEndToken | ParensStartToken | ParensEndToken | CDOCommentToken | BadCDOCommentToken | CommentToken | BadCommentToken | WhitespaceToken | IncludesToken | DashMatchToken | LessThanToken | GreaterThanToken | PseudoClassToken | PseudoClassFunctionToken | DelimToken | BadUrlToken | UrlToken | ImportantToken | ColorToken | AttrToken | EOFToken;
+
+interface ErrorDescription {
+
+    // drop rule or declaration | fix rule or declaration
+    action: 'drop';
+    message: string;
+    location: {
+        src: string,
+        lin: number,
+        col: number;
+    };
+    error?: Error;
+}
+
+interface ParserOptions {
+
+    src?: string;
+    sourcemap?: boolean;
+    compress?: boolean;
+    removeEmpty?: boolean;
+    resolveUrls?: boolean;
+    resolveImport?: boolean;
+    cwd?: string;
+    load?: (url: string, currentUrl: string) => Promise<string>;
+    resolve?: (url: string, currentUrl: string, currentWorkingDirectory?: string) => { absolute: string, relative: string };
+    nodeEventFilter?: NodeType[]
+}
+
+interface RenderOptions {
+
+    compress?: boolean;
+    preserveLicense?: boolean;
+    indent?: string;
+    newLine?: string;
+    removeComments?: boolean;
+    colorConvert?: boolean;
+}
+
+interface TransformOptions extends ParserOptions, RenderOptions {
+
+}
+
+interface ParseResult {
+    ast: AstRuleStyleSheet;
+    errors: ErrorDescription[];
+    bytesIn: number;
+}
+
+interface RenderResult {
+    code: string ;
+}
+
+interface TransformResult extends ParseResult, RenderResult {
+
+    stats: {
+        bytesIn: number;
+        bytesOut: number;
+        parse: string;
+        render: string;
+        total: string;
+    }
+}
+
+interface Position {
+
+    ind: number;
+    lin: number;
+    col: number;
+}
+
+interface Location {
+
+    sta: Position;
+    // end: Position;
+    src: string;
+}
+
+declare type NodeType = 'StyleSheet' | 'InvalidComment' | 'Comment' | 'Declaration' | 'InvalidAtRule' | 'AtRule' | 'Rule';
+
+interface Node {
+
+    typ: NodeType;
+    loc?: Location;
+}
+
+interface AstComment extends Node {
+
+    typ: 'Comment',
+    val: string;
+}
+interface AstDeclaration extends Node {
+
+    nam: string,
+    val: Token[];
+    typ: 'Declaration'
+}
+
+interface AstRule extends Node {
+
+    typ: 'Rule',
+    sel: string,
+    chi: Array<AstDeclaration | AstComment | AstRuleList>
+}
+
+interface AstAtRule extends Node {
+
+    nam: string;
+    val: string;
+    chi?: Array<AstDeclaration | AstComment> | Array<AstRule | AstComment>
+}
+
+interface AstRuleList extends Node {
+
+    chi: Array<Node | AstComment>
+}
+
+interface AstRuleStyleSheet extends AstRuleList {
+    typ: 'StyleSheet',
+    chi: Array<AstRuleList | AstComment>
+}
+
+type AstNode =
+    AstRuleStyleSheet
+    | AstRuleList
+    | AstComment
+    | AstAtRule
+    | AstRule
+    | AstDeclaration;
+
+declare function deduplicate(ast: AstNode, options?: ParserOptions, recursive?: boolean): AstNode;
+declare function hasDeclaration(node: AstAtRule | AstRule | AstRuleList): boolean;
+declare function deduplicateRule(ast: AstNode, options?: ParserOptions): AstNode;
+
+declare function render(data: AstNode, opt?: RenderOptions): RenderResult;
+declare function renderToken(token: Token, options?: RenderOptions): string;
+
+declare function walk(node: AstNode): Generator<{
+    node: AstNode;
+    parent?: AstRuleList;
+    root?: AstRuleList;
+}>;
+
+declare function load(url: string, currentFile: string): Promise<string>;
+
+declare const matchUrl: RegExp;
+declare function dirname(path: string): string;
+declare function resolve(url: string, currentDirectory: string, cwd?: string): {
+    absolute: string;
+    relative: string;
+};
+
+declare function parse(iterator: string, opt?: ParserOptions): Promise<ParseResult>;
+declare function transform(css: string, options?: TransformOptions): Promise<TransformResult>;
+
+export { deduplicate, deduplicateRule, dirname, hasDeclaration, load, matchUrl, parse, render, renderToken, resolve, transform, walk };

package/dist/index.js

@@ -0,0 +1,6 @@
+export { parse, transform } from './node/index.js';
+export { deduplicate, deduplicateRule, hasDeclaration } from './lib/parser/deduplicate.js';
+export { render, renderToken } from './lib/renderer/render.js';
+export { walk } from './lib/walker/walk.js';
+export { load } from './node/load.js';
+export { dirname, matchUrl, resolve } from './lib/fs/resolve.js';

package/dist/lib/fs/resolve.js

@@ -0,0 +1,100 @@
+const matchUrl = /^(https?:)?\/\//;
+function dirname(path) {
+    if (path == '/' || path === '') {
+        return path;
+    }
+    let i = 0;
+    let parts = [''];
+    for (; i < path.length; i++) {
+        const chr = path.charAt(i);
+        if (chr == '/') {
+            parts.push('');
+        }
+        else if (chr == '?' || chr == '#') {
+            break;
+        }
+        else {
+            parts[parts.length - 1] += chr;
+        }
+    }
+    parts.pop();
+    return parts.length == 0 ? '/' : parts.join('/');
+}
+function splitPath(result) {
+    const parts = [''];
+    let i = 0;
+    for (; i < result.length; i++) {
+        const chr = result.charAt(i);
+        if (chr == '/') {
+            parts.push('');
+        }
+        else if (chr == '?' || chr == '#') {
+            break;
+        }
+        else {
+            parts[parts.length - 1] += chr;
+        }
+    }
+    let k = parts.length;
+    while (k--) {
+        if (parts[k] == '.') {
+            parts.splice(k, 1);
+        }
+        else if (parts[k] == '..') {
+            parts.splice(k - 1, 2);
+        }
+    }
+    return { parts, i };
+}
+function resolve(url, currentDirectory, cwd) {
+    if (matchUrl.test(url)) {
+        return {
+            absolute: url,
+            relative: url
+        };
+    }
+    if (matchUrl.test(currentDirectory)) {
+        const path = new URL(url, currentDirectory).href;
+        return {
+            absolute: path,
+            relative: path
+        };
+    }
+    let result;
+    if (url.charAt(0) == '/') {
+        result = url;
+    }
+    else if (currentDirectory.charAt(0) == '/') {
+        result = dirname(currentDirectory) + '/' + url;
+    }
+    else if (currentDirectory === '' || dirname(currentDirectory) === '') {
+        result = url;
+    }
+    else {
+        result = dirname(currentDirectory) + '/' + url;
+    }
+    let { parts, i } = splitPath(result);
+    if (parts.length == 0) {
+        const path = result.charAt(0) == '/' ? '/' : '';
+        return {
+            absolute: path,
+            relative: path
+        };
+    }
+    const absolute = parts.join('/');
+    const { parts: dirs } = splitPath(cwd ?? currentDirectory);
+    for (const p of dirs) {
+        if (parts[0] == p) {
+            parts.shift();
+        }
+        else {
+            parts.unshift('..');
+        }
+    }
+    return {
+        absolute,
+        relative: parts.join('/') + (i < result.length ? result.slice(i) : '')
+    };
+}
+
+export { dirname, matchUrl, resolve };

package/dist/lib/parser/declaration/list.js

@@ -0,0 +1,66 @@
+import { PropertySet } from './set.js';
+import { getConfig } from '../utils/config.js';
+import { PropertyMap } from './map.js';
+
+const config = getConfig();
+class PropertyList {
+    declarations;
+    constructor() {
+        this.declarations = new Map;
+    }
+    add(declaration) {
+        if (declaration.typ != 'Declaration') {
+            this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
+            return this;
+        }
+        const propertyName = declaration.nam;
+        if (propertyName in config.properties) {
+            // @ts-ignore
+            const shorthand = config.properties[propertyName].shorthand;
+            if (!this.declarations.has(shorthand)) {
+                // @ts-ignore
+                this.declarations.set(shorthand, new PropertySet(config.properties[shorthand]));
+            }
+            this.declarations.get(shorthand).add(declaration);
+            return this;
+        }
+        if (propertyName in config.map) {
+            // @ts-ignore
+            const shorthand = config.map[propertyName].shorthand;
+            if (!this.declarations.has(shorthand)) {
+                // @ts-ignore
+                this.declarations.set(shorthand, new PropertyMap(config.map[shorthand]));
+            }
+            this.declarations.get(shorthand).add(declaration);
+            return this;
+        }
+        this.declarations.set(propertyName, declaration);
+        return this;
+    }
+    [Symbol.iterator]() {
+        let iterator = this.declarations.values();
+        const iterators = [];
+        return {
+            next() {
+                let value = iterator.next();
+                while ((value.done && iterators.length > 0) ||
+                    value.value instanceof PropertySet ||
+                    value.value instanceof PropertyMap) {
+                    if (value.value instanceof PropertySet || value.value instanceof PropertyMap) {
+                        iterators.unshift(iterator);
+                        // @ts-ignore
+                        iterator = value.value[Symbol.iterator]();
+                        value = iterator.next();
+                    }
+                    if (value.done && iterators.length > 0) {
+                        iterator = iterators.shift();
+                        value = iterator.next();
+                    }
+                }
+                return value;
+            }
+        };
+    }
+}
+
+export { PropertyList };