@tbela99/css-parser 1.4.2 → 1.4.3

package/dist/lib/validation/parser/typedef.d.ts

@@ -0,0 +1,95 @@
+export declare enum ValidationTokenEnum {
+    Root = 0,
+    Keyword = 1,
+    PropertyType = 2,
+    DeclarationType = 3,
+    AtRule = 4,
+    FunctionDefinition = 5,
+    OpenBracket = 6,
+    CloseBracket = 7,
+    OpenParenthesis = 8,
+    CloseParenthesis = 9,
+    Comma = 10,
+    Pipe = 11,
+    Column = 12,
+    Star = 13,
+    OpenCurlyBrace = 14,
+    CloseCurlyBrace = 15,
+    HashMark = 16,
+    QuestionMark = 17,
+    Function = 18,
+    Number = 19,
+    Whitespace = 20,
+    Parenthesis = 21,
+    Bracket = 22,
+    Block = 23,
+    Plus = 24,
+    Separator = 25,
+    Exclamation = 26,
+    Ampersand = 27,
+    PipeToken = 28,
+    ColumnToken = 29,
+    AmpersandToken = 30,
+    Parens = 31,
+    PseudoClassToken = 32,
+    PseudoClassFunctionToken = 33,
+    StringToken = 34,
+    AtRuleDefinition = 35,
+    DeclarationNameToken = 36,
+    DeclarationDefinitionToken = 37,
+    SemiColon = 38,
+    Character = 39,
+    InfinityToken = 40,
+    LessThan = 41,
+    GreaterThan = 42,
+    /**
+     * end of token stream
+     */
+    EOF = 43,
+    /**
+     * optional group or tokens, used to group validation tokens
+     *
+     * ```ts
+     * // <bg-layer>#? , <final-bg-layer> -> [<bg-layer>#? ,]? <final-bg-layer>
+     * // , <angular-color-stop> ]#? -> [, <angular-color-stop> ]#?]?
+     * ```
+     */
+    OptionalGroupToken = 44,
+    /**
+     * dimension token
+     *
+     * ```ts
+     * // <time [0s,∞]> -> {
+     * //     typ: ValidationTokenEnum.PropertyType
+     * //     val: 'time',
+     * //     range: {
+     * //         min: ValidationNumberToken,
+     * //         max: null | ValidationNumberToken | ValidationInfinityToken
+     * //     }
+     * // }
+     * ```
+     */
+    Dimension = 45,
+    DisallowWhitespace = 46,
+    Colon = 47
+}
+export declare enum ValidationSyntaxGroupEnum {
+    Declarations = "declarations",
+    Functions = "functions",
+    Syntaxes = "syntaxes",
+    Selectors = "selectors",
+    AtRules = "atRules",
+    Units = "units",
+    Languages = "languages",
+    mediaFeatures = "mediaFeatures"
+}
+export declare enum MediaFeatureType {
+    BooleanType = "boolean",
+    IntergerType = "integer",
+    KeywordType = "keyword",
+    LengthType = "length",
+    NumberType = "number",
+    RatioType = "ratio",
+    ResolutionType = "resolution",
+    StringType = "string"
+}

package/dist/lib/validation/parser/typedef.js

@@ -0,0 +1,100 @@
+var ValidationTokenEnum;
+(function (ValidationTokenEnum) {
+    ValidationTokenEnum[ValidationTokenEnum["Root"] = 0] = "Root";
+    ValidationTokenEnum[ValidationTokenEnum["Keyword"] = 1] = "Keyword";
+    ValidationTokenEnum[ValidationTokenEnum["PropertyType"] = 2] = "PropertyType";
+    ValidationTokenEnum[ValidationTokenEnum["DeclarationType"] = 3] = "DeclarationType";
+    ValidationTokenEnum[ValidationTokenEnum["AtRule"] = 4] = "AtRule";
+    ValidationTokenEnum[ValidationTokenEnum["FunctionDefinition"] = 5] = "FunctionDefinition";
+    ValidationTokenEnum[ValidationTokenEnum["OpenBracket"] = 6] = "OpenBracket";
+    ValidationTokenEnum[ValidationTokenEnum["CloseBracket"] = 7] = "CloseBracket";
+    ValidationTokenEnum[ValidationTokenEnum["OpenParenthesis"] = 8] = "OpenParenthesis";
+    ValidationTokenEnum[ValidationTokenEnum["CloseParenthesis"] = 9] = "CloseParenthesis";
+    ValidationTokenEnum[ValidationTokenEnum["Comma"] = 10] = "Comma";
+    ValidationTokenEnum[ValidationTokenEnum["Pipe"] = 11] = "Pipe";
+    ValidationTokenEnum[ValidationTokenEnum["Column"] = 12] = "Column";
+    ValidationTokenEnum[ValidationTokenEnum["Star"] = 13] = "Star";
+    ValidationTokenEnum[ValidationTokenEnum["OpenCurlyBrace"] = 14] = "OpenCurlyBrace";
+    ValidationTokenEnum[ValidationTokenEnum["CloseCurlyBrace"] = 15] = "CloseCurlyBrace";
+    ValidationTokenEnum[ValidationTokenEnum["HashMark"] = 16] = "HashMark";
+    ValidationTokenEnum[ValidationTokenEnum["QuestionMark"] = 17] = "QuestionMark";
+    ValidationTokenEnum[ValidationTokenEnum["Function"] = 18] = "Function";
+    ValidationTokenEnum[ValidationTokenEnum["Number"] = 19] = "Number";
+    ValidationTokenEnum[ValidationTokenEnum["Whitespace"] = 20] = "Whitespace";
+    ValidationTokenEnum[ValidationTokenEnum["Parenthesis"] = 21] = "Parenthesis";
+    ValidationTokenEnum[ValidationTokenEnum["Bracket"] = 22] = "Bracket";
+    ValidationTokenEnum[ValidationTokenEnum["Block"] = 23] = "Block";
+    ValidationTokenEnum[ValidationTokenEnum["Plus"] = 24] = "Plus";
+    ValidationTokenEnum[ValidationTokenEnum["Separator"] = 25] = "Separator";
+    ValidationTokenEnum[ValidationTokenEnum["Exclamation"] = 26] = "Exclamation";
+    ValidationTokenEnum[ValidationTokenEnum["Ampersand"] = 27] = "Ampersand";
+    ValidationTokenEnum[ValidationTokenEnum["PipeToken"] = 28] = "PipeToken";
+    ValidationTokenEnum[ValidationTokenEnum["ColumnToken"] = 29] = "ColumnToken";
+    ValidationTokenEnum[ValidationTokenEnum["AmpersandToken"] = 30] = "AmpersandToken";
+    ValidationTokenEnum[ValidationTokenEnum["Parens"] = 31] = "Parens";
+    ValidationTokenEnum[ValidationTokenEnum["PseudoClassToken"] = 32] = "PseudoClassToken";
+    ValidationTokenEnum[ValidationTokenEnum["PseudoClassFunctionToken"] = 33] = "PseudoClassFunctionToken";
+    ValidationTokenEnum[ValidationTokenEnum["StringToken"] = 34] = "StringToken";
+    ValidationTokenEnum[ValidationTokenEnum["AtRuleDefinition"] = 35] = "AtRuleDefinition";
+    ValidationTokenEnum[ValidationTokenEnum["DeclarationNameToken"] = 36] = "DeclarationNameToken";
+    ValidationTokenEnum[ValidationTokenEnum["DeclarationDefinitionToken"] = 37] = "DeclarationDefinitionToken";
+    ValidationTokenEnum[ValidationTokenEnum["SemiColon"] = 38] = "SemiColon";
+    ValidationTokenEnum[ValidationTokenEnum["Character"] = 39] = "Character";
+    ValidationTokenEnum[ValidationTokenEnum["InfinityToken"] = 40] = "InfinityToken";
+    ValidationTokenEnum[ValidationTokenEnum["LessThan"] = 41] = "LessThan";
+    ValidationTokenEnum[ValidationTokenEnum["GreaterThan"] = 42] = "GreaterThan";
+    /**
+     * end of token stream
+     */
+    ValidationTokenEnum[ValidationTokenEnum["EOF"] = 43] = "EOF";
+    /**
+     * optional group or tokens, used to group validation tokens
+     *
+     * ```ts
+     * // <bg-layer>#? , <final-bg-layer> -> [<bg-layer>#? ,]? <final-bg-layer>
+     * // , <angular-color-stop> ]#? -> [, <angular-color-stop> ]#?]?
+     * ```
+     */
+    ValidationTokenEnum[ValidationTokenEnum["OptionalGroupToken"] = 44] = "OptionalGroupToken";
+    /**
+     * dimension token
+     *
+     * ```ts
+     * // <time [0s,∞]> -> {
+     * //     typ: ValidationTokenEnum.PropertyType
+     * //     val: 'time',
+     * //     range: {
+     * //         min: ValidationNumberToken,
+     * //         max: null | ValidationNumberToken | ValidationInfinityToken
+     * //     }
+     * // }
+     * ```
+     */
+    ValidationTokenEnum[ValidationTokenEnum["Dimension"] = 45] = "Dimension";
+    ValidationTokenEnum[ValidationTokenEnum["DisallowWhitespace"] = 46] = "DisallowWhitespace";
+    ValidationTokenEnum[ValidationTokenEnum["Colon"] = 47] = "Colon";
+})(ValidationTokenEnum || (ValidationTokenEnum = {}));
+var ValidationSyntaxGroupEnum;
+(function (ValidationSyntaxGroupEnum) {
+    ValidationSyntaxGroupEnum["Declarations"] = "declarations";
+    ValidationSyntaxGroupEnum["Functions"] = "functions";
+    ValidationSyntaxGroupEnum["Syntaxes"] = "syntaxes";
+    ValidationSyntaxGroupEnum["Selectors"] = "selectors";
+    ValidationSyntaxGroupEnum["AtRules"] = "atRules";
+    ValidationSyntaxGroupEnum["Units"] = "units";
+    ValidationSyntaxGroupEnum["Languages"] = "languages";
+    ValidationSyntaxGroupEnum["mediaFeatures"] = "mediaFeatures";
+})(ValidationSyntaxGroupEnum || (ValidationSyntaxGroupEnum = {}));
+var MediaFeatureType;
+(function (MediaFeatureType) {
+    MediaFeatureType["BooleanType"] = "boolean";
+    MediaFeatureType["IntergerType"] = "integer";
+    MediaFeatureType["KeywordType"] = "keyword";
+    MediaFeatureType["LengthType"] = "length";
+    MediaFeatureType["NumberType"] = "number";
+    MediaFeatureType["RatioType"] = "ratio";
+    MediaFeatureType["ResolutionType"] = "resolution";
+    MediaFeatureType["StringType"] = "string";
+})(MediaFeatureType || (MediaFeatureType = {}));
+
+export { MediaFeatureType, ValidationSyntaxGroupEnum, ValidationTokenEnum };

package/dist/lib/validation/utils/list.d.ts

@@ -0,0 +1,4 @@
+import { EnumToken } from "../../ast/types.ts";
+import type { Token } from "../../../@types/index.d.ts";
+export declare function stripCommaToken(tokenList: Token[]): Token[] | null;
+export declare function splitTokenList(tokenList: Token[], split?: EnumToken[], includeSplitToken?: boolean): Token[][];

package/dist/lib/validation/utils/list.js

@@ -1,18 +1,8 @@
 import { EnumToken } from '../../ast/types.js';
-import '../../ast/minify.js';
-import '../../ast/walk.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
 
 function stripCommaToken(tokenList) {
     let result = [];
     for (let i = 0; i < tokenList.length; i++) {
-        if (tokenList[i].typ != EnumToken.WhitespaceTokenType) {
-            tokenList[i];
-        }
         if (tokenList[i].typ == EnumToken.CommentTokenType || tokenList[i].typ == EnumToken.CommaTokenType) {
             continue;
         }
@@ -20,9 +10,12 @@ function stripCommaToken(tokenList) {
     }
     return result;
 }
-function splitTokenList(tokenList, split = [EnumToken.CommaTokenType]) {
+function splitTokenList(tokenList, split = [EnumToken.CommaTokenType], includeSplitToken = false) {
     return tokenList.reduce((acc, curr) => {
         if (split.includes(curr.typ)) {
+            if (includeSplitToken && Array.isArray(acc[acc.length - 1])) {
+                acc[acc.length - 1].push(curr);
+            }
             acc.push([]);
         }
         else {

package/dist/lib/validation/utils/whitespace.d.ts

@@ -0,0 +1,2 @@
+import type { Token } from "../../../@types/token.d.ts";
+export declare function consumeWhitespace(tokens: Token[]): boolean;

package/dist/lib/validation/utils/whitespace.js

@@ -1,11 +1,4 @@
 import { EnumToken } from '../../ast/types.js';
-import '../../ast/minify.js';
-import '../../ast/walk.js';
-import '../../parser/parse.js';
-import '../../parser/tokenize.js';
-import '../../parser/utils/config.js';
-import '../../syntax/color/utils/constants.js';
-import '../../renderer/sourcemap/lib/encode.js';
 
 function consumeWhitespace(tokens) {
     if (tokens.length == 0) {
@@ -14,7 +7,8 @@ function consumeWhitespace(tokens) {
     if (tokens[0].typ != EnumToken.WhitespaceTokenType && tokens[0].typ != EnumToken.DescendantCombinatorTokenType) {
         return false;
     }
-    while (tokens.length > 0 && (tokens[0].typ == EnumToken.WhitespaceTokenType || tokens[0].typ == EnumToken.DescendantCombinatorTokenType)) {
+    while (tokens.length > 0 &&
+        (tokens[0].typ == EnumToken.WhitespaceTokenType || tokens[0].typ == EnumToken.DescendantCombinatorTokenType)) {
         tokens.shift();
     }
     return true;

package/dist/node.d.ts

@@ -0,0 +1,207 @@
+import type { AstNode, ParseResult, ParserOptions, RenderOptions, RenderResult, TransformOptions, TransformResult } from "./@types/index.d.ts";
+import { dirname, resolve } from "./lib/fs/resolve.ts";
+import { ResponseType } from "./types.ts";
+export type * from "./@types/index.d.ts";
+export type * from "./@types/ast.d.ts";
+export type * from "./@types/token.d.ts";
+export type * from "./@types/parse.d.ts";
+export type * from "./@types/validation.d.ts";
+export type * from "./@types/walker.d.ts";
+export type { AstNode, ParseResult, ParserOptions, RenderOptions, RenderResult, TransformOptions, TransformResult, } from "./@types/index.d.ts";
+export { minify } from "./lib/ast/minify.ts";
+export { expand } from "./lib/ast/expand.ts";
+export { walk, walkValues, WalkerEvent, WalkerOptionEnum } from "./lib/ast/walk.ts";
+export { parseString } from "./lib/parser/parse.ts";
+export { renderToken } from "./lib/renderer/render.ts";
+export { convertColor } from "./lib/syntax/color/color.ts";
+export { isOkLabClose, okLabDistance } from "./lib/syntax/color/utils/distance.ts";
+export { parseDeclarations } from "./lib/parser/parse.ts";
+export { find, findLast, findByValue, findAll } from "./lib/ast/find.ts";
+export { cloneNode } from "./lib/ast/clone.ts";
+export { EnumToken, ColorType, ValidationLevel, ModuleScopeEnumOptions, ModuleCaseTransformEnum, } from "./lib/ast/types.ts";
+export { SourceMap } from "./lib/renderer/sourcemap/sourcemap.ts";
+export type { ValidationToken } from "./lib/validation/parser/types.d.ts";
+export { FeatureWalkMode } from "./lib/ast/features/type.ts";
+export { dirname, resolve, ResponseType };
+/**
+ * load file or url
+ * @param url
+ * @param currentDirectory
+ * @param responseType
+ * @throws Error file not found
+ *
+ * ```ts
+ * import {load, ResponseType} from '@tbela99/css-parser';
+ * const result = await load(file, '.', ResponseType.ArrayBuffer) as ArrayBuffer;
+ * ```
+ */
+export declare function load(url: string, currentDirectory?: string, responseType?: boolean | ResponseType): Promise<string | ArrayBuffer | ReadableStream<Uint8Array<ArrayBufferLike>>>;
+/**
+ * render the ast tree
+ * @param data
+ * @param options
+ * @param mapping
+ *
+ * Example:
+ *
+ * ```ts
+ *
+ *  import {render, ColorType} from '@tbela99/css-parser';
+ *
+ *  const css = 'body { color: color(from hsl(0 100% 50%) xyz x y z); }';
+ *  const parseResult = await parse(css);
+ *
+ * let renderResult = render(parseResult.ast);
+ * console.log(result.code);
+ *
+ * // body{color:red}
+ *
+ *
+ * renderResult = render(parseResult.ast, {beautify: true, convertColor: ColorType.SRGB});
+ * console.log(renderResult.code);
+ *
+ * // body {
+ * //  color: color(srgb 1 0 0)
+ * // }
+ * ```
+ */
+export declare function render(data: AstNode, options?: RenderOptions, mapping?: {
+    mapping: Record<string, string>;
+    importMapping: Record<string, Record<string, string>> | null;
+} | null): RenderResult;
+/**
+ * parse css file
+ * @param file url or path
+ * @param options
+ * @param asStream load file as stream
+ *
+ * @throws Error file not found
+ *
+ * Example:
+ *
+ * ```ts
+ *
+ *  import {parseFile} from '@tbela99/css-parser';
+ *
+ *  // remote file
+ * let result = await parseFile('https://docs.deno.com/styles.css');
+ * console.log(result.ast);
+ *
+ * // local file
+ * result = await parseFile('./css/styles.css');
+ * console.log(result.ast);
+ * ```
+ */
+export declare function parseFile(file: string, options?: ParserOptions, asStream?: boolean): Promise<ParseResult>;
+/**
+ * parse css
+ * @param stream
+ * @param options
+ *
+ * Example:
+ *
+ * ```ts
+ *
+ * import {parse} from '@tbela99/css-parser';
+ *
+ *  // css string
+ *  let result = await parse(css);
+ *  console.log(result.ast);
+ * ```
+ *
+ * Example using stream
+ *
+ * ```ts
+ *
+ * import {parse} from '@tbela99/css-parser';
+ * import {Readable} from "node:stream";
+ *
+ * // usage: node index.ts < styles.css or cat styles.css | node index.ts
+ *
+ *  const readableStream = Readable.toWeb(process.stdin);
+ *  let result = await parse(readableStream, {beautify: true});
+ *
+ *  console.log(result.ast);
+ * ```
+ *
+ * Example using fetch and readable stream
+ *
+ * ```ts
+ *
+ *  import {parse} from '@tbela99/css-parser';
+ *
+ *  const response = await fetch('https://docs.deno.com/styles.css');
+ *  const result = await parse(response.body, {beautify: true});
+ *
+ *  console.log(result.ast);
+ * ```
+ */
+export declare function parse(stream: string | ReadableStream<Uint8Array>, options?: ParserOptions): Promise<ParseResult>;
+/**
+ * transform css file
+ * @param file url or path
+ * @param options
+ * @param asStream load file as stream
+ *
+ * @throws Error file not found
+ *
+ * Example:
+ *
+ * ```ts
+ *
+ *  import {transformFile} from '@tbela99/css-parser';
+ *
+ *  // remote file
+ * let result = await transformFile('https://docs.deno.com/styles.css');
+ * console.log(result.code);
+ *
+ * // local file
+ * result = await transformFile('./css/styles.css');
+ * console.log(result.code);
+ * ```
+ */
+export declare function transformFile(file: string, options?: TransformOptions, asStream?: boolean): Promise<TransformResult>;
+/**
+ * transform css
+ * @param css
+ * @param options
+ *
+ * Example:
+ *
+ * ```ts
+ *
+ * import {transform} from '@tbela99/css-parser';
+ *
+ *  // css string
+ *  const result = await transform(css);
+ *  console.log(result.code);
+ * ```
+ *
+ * Example using stream
+ *
+ * ```ts
+ *
+ * import {transform} from '@tbela99/css-parser';
+ * import {Readable} from "node:stream";
+ *
+ * // usage: node index.ts < styles.css or cat styles.css | node index.ts
+ *
+ *  const readableStream = Readable.toWeb(process.stdin);
+ *  const result = await transform(readableStream, {beautify: true});
+ *
+ *  console.log(result.code);
+ * ```
+ *
+ * Example using fetch
+ *
+ * ```ts
+ *
+ *  import {transform} from '@tbela99/css-parser';
+ *
+ *  const response = await fetch('https://docs.deno.com/styles.css');
+ *  result = await transform(response.body, {beautify: true});
+ *
+ *  console.log(result.code);
+ * ```
+ */
+export declare function transform(css: string | ReadableStream<Uint8Array>, options?: TransformOptions): Promise<TransformResult>;

package/dist/node.js

@@ -1,28 +1,24 @@
 import process from 'node:process';
+import { Readable } from 'node:stream';
+import { createReadStream } from 'node:fs';
+import { lstat, readFile } from 'node:fs/promises';
+import { doParse } from './lib/parser/parse.js';
+export { parseDeclarations, parseString } from './lib/parser/parse.js';
+import { doRender } from './lib/renderer/render.js';
+export { renderToken } from './lib/renderer/render.js';
 import { ModuleScopeEnumOptions } from './lib/ast/types.js';
 export { ColorType, EnumToken, ModuleCaseTransformEnum, ValidationLevel } from './lib/ast/types.js';
+import { tokenizeStream, tokenize } from './lib/parser/tokenize.js';
+import { resolve, matchUrl, dirname } from './lib/fs/resolve.js';
+import { ResponseType } from './types.js';
 export { minify } from './lib/ast/minify.js';
-export { WalkerEvent, WalkerOptionEnum, walk, walkValues } from './lib/ast/walk.js';
 export { expand } from './lib/ast/expand.js';
-import { doRender } from './lib/renderer/render.js';
-export { renderToken } from './lib/renderer/render.js';
-export { SourceMap } from './lib/renderer/sourcemap/sourcemap.js';
-import { doParse } from './lib/parser/parse.js';
-export { parseDeclarations, parseString, parseTokens } from './lib/parser/parse.js';
-import { tokenizeStream, tokenize } from './lib/parser/tokenize.js';
-import './lib/parser/utils/config.js';
+export { WalkerEvent, WalkerOptionEnum, walk, walkValues } from './lib/ast/walk.js';
 export { convertColor } from './lib/syntax/color/color.js';
-import './lib/syntax/color/utils/constants.js';
 export { isOkLabClose, okLabDistance } from './lib/syntax/color/utils/distance.js';
-import './lib/validation/config.js';
-import './lib/validation/parser/parse.js';
-import './lib/validation/syntaxes/complex-selector.js';
-import './lib/validation/syntax.js';
-import { resolve, matchUrl, dirname } from './lib/fs/resolve.js';
-import { Readable } from 'node:stream';
-import { createReadStream } from 'node:fs';
-import { lstat, readFile } from 'node:fs/promises';
-import { ResponseType } from './types.js';
+export { find, findAll, findByValue, findLast } from './lib/ast/find.js';
+export { cloneNode } from './lib/ast/clone.js';
+export { SourceMap } from './lib/renderer/sourcemap/sourcemap.js';
 export { FeatureWalkMode } from './lib/ast/features/type.js';
 
 /**
@@ -37,9 +33,9 @@ export { FeatureWalkMode } from './lib/ast/features/type.js';
  * const result = await load(file, '.', ResponseType.ArrayBuffer) as ArrayBuffer;
  * ```
  */
-async function load(url, currentDirectory = '.', responseType = false) {
+async function load(url, currentDirectory = ".", responseType = false) {
     const resolved = resolve(url, currentDirectory);
-    if (typeof responseType == 'boolean') {
+    if (typeof responseType == "boolean") {
         responseType = responseType ? ResponseType.ReadableStream : ResponseType.Text;
     }
     if (matchUrl.test(resolved.absolute)) {
@@ -50,21 +46,23 @@ async function load(url, currentDirectory = '.', responseType = false) {
             if (responseType == ResponseType.ArrayBuffer) {
                 return response.arrayBuffer();
             }
-            return responseType == ResponseType.ReadableStream ? response.body : response.text();
+            return responseType == ResponseType.ReadableStream
+                ? response.body
+                : response.text();
         });
     }
     try {
         const stats = await lstat(resolved.absolute);
         if (stats.isFile()) {
             if (responseType == ResponseType.Text) {
-                return readFile(resolved.absolute, 'utf-8');
+                return readFile(resolved.absolute, "utf-8");
             }
             if (responseType == ResponseType.ArrayBuffer) {
-                return readFile(resolved.absolute).then(buffer => buffer.buffer);
+                return readFile(resolved.absolute).then((buffer) => buffer.buffer);
             }
             return Readable.toWeb(createReadStream(resolved.absolute, {
-                encoding: 'utf-8',
-                highWaterMark: 64 * 1024
+                encoding: "utf-8",
+                highWaterMark: 64 * 1024,
             }));
         }
     }
@@ -129,7 +127,7 @@ function render(data, options = {}, mapping) {
  * ```
  */
 async function parseFile(file, options = {}, asStream = false) {
-    return Promise.resolve((options.load ?? load)(file, '.', asStream)).then(stream => parse(stream, { src: file, ...options }));
+    return Promise.resolve((options.load ?? load)(file, ".", asStream)).then((stream) => parse(stream, { src: file, ...options }));
 }
 /**
  * parse css
@@ -175,18 +173,21 @@ async function parseFile(file, options = {}, asStream = false) {
  * ```
  */
 async function parse(stream, options = {}) {
-    return doParse(stream instanceof ReadableStream ? tokenizeStream(stream) : tokenize({
+    options.parseInfo = {
         stream,
-        buffer: '',
+        buffer: "",
+        src: options.src ?? "",
         offset: 0,
-        position: { ind: 0, lin: 1, col: 1 },
-        currentPosition: { ind: -1, lin: 1, col: 0 }
-    }), Object.assign(options, {
+        time: 0,
+        position: { ind: 0, lin: 1, col: 0 },
+        currentPosition: { ind: -1, lin: 1, col: 0 },
+    };
+    return doParse(stream instanceof ReadableStream ? tokenizeStream(stream, options.parseInfo) : tokenize(options.parseInfo), Object.assign(options, {
         load,
         resolve,
         dirname,
-        cwd: options.cwd ?? process.cwd()
-    })).then(result => {
+        cwd: options.cwd ?? process.cwd(),
+    })).then((result) => {
         const { revMapping, ...res } = result;
         return res;
     });
@@ -215,7 +216,7 @@ async function parse(stream, options = {}) {
  * ```
  */
 async function transformFile(file, options = {}, asStream = false) {
-    return Promise.resolve((options.load ?? load)(file, '.', asStream)).then(stream => transform(stream, { src: file, ...options }));
+    return Promise.resolve((options.load ?? load)(file, ".", asStream)).then((stream) => transform(stream, { src: file, ...options }));
 }
 /**
  * transform css
@@ -266,18 +267,20 @@ async function transform(css, options = {}) {
     return parse(css, options).then((parseResult) => {
         let mapping = null;
         let importMapping = null;
-        if (typeof options.module == 'number' && (options.module & ModuleScopeEnumOptions.ICSS)) {
+        if (typeof options.module == "number" && options.module & ModuleScopeEnumOptions.ICSS) {
             mapping = parseResult.mapping;
             importMapping = parseResult.importMapping;
         }
-        else if (typeof options.module == 'object' && typeof options.module.scoped == 'number' && (options.module.scoped & ModuleScopeEnumOptions.ICSS)) {
+        else if (typeof options.module == "object" &&
+            typeof options.module.scoped == "number" &&
+            options.module.scoped & ModuleScopeEnumOptions.ICSS) {
             mapping = parseResult.mapping;
             importMapping = parseResult.importMapping;
         }
         // ast already expanded by parse
         const rendered = render(parseResult.ast, {
             ...options,
-            expandNestingRules: false
+            expandNestingRules: false,
         }, mapping != null ? { mapping, importMapping } : null);
         return {
             ...parseResult,
@@ -287,8 +290,8 @@ async function transform(css, options = {}) {
                 bytesOut: rendered.code.length,
                 ...parseResult.stats,
                 render: rendered.stats.total,
-                total: `${(performance.now() - startTime).toFixed(2)}ms`
-            }
+                total: `${(performance.now() - startTime).toFixed(2)}ms`,
+            },
         };
     });
 }