@projectwallace/css-parser 0.13.5 → 0.13.8

package/dist/tokenize-BQFB1jXg.js

@@ -0,0 +1,540 @@
+let char_types = new Uint8Array(128);
+for (let i = 48; i <= 57; i++) char_types[i] = 2;
+for (let i = 48; i <= 57; i++) char_types[i] |= 4;
+for (let i = 65; i <= 70; i++) char_types[i] = 4;
+for (let i = 97; i <= 102; i++) char_types[i] = 4;
+for (let i = 65; i <= 90; i++) char_types[i] |= 1;
+for (let i = 97; i <= 122; i++) char_types[i] |= 1;
+char_types[32] = 8;
+char_types[9] = 8;
+char_types[10] = 16;
+char_types[13] = 16;
+char_types[12] = 16;
+for (let i = 0; i < 128; i++) if (char_types[i] & 3) char_types[i] |= 32;
+char_types[45] |= 32;
+char_types[95] |= 32;
+function is_hex_digit(ch) {
+	return ch < 128 && (char_types[ch] & 4) !== 0;
+}
+function is_alpha(ch) {
+	return ch < 128 && (char_types[ch] & 1) !== 0;
+}
+function is_whitespace(ch) {
+	return ch < 128 && (char_types[ch] & 8) !== 0;
+}
+function is_ident_start(ch) {
+	if (ch >= 128) return true;
+	if (ch === 95) return true;
+	return is_alpha(ch);
+}
+//#endregion
+//#region src/token-types.ts
+const TOKEN_IDENT = 1;
+const TOKEN_FUNCTION = 2;
+const TOKEN_AT_KEYWORD = 3;
+const TOKEN_HASH = 4;
+const TOKEN_STRING = 5;
+const TOKEN_BAD_STRING = 6;
+const TOKEN_URL = 7;
+const TOKEN_BAD_URL = 8;
+const TOKEN_DELIM = 9;
+const TOKEN_NUMBER = 10;
+const TOKEN_PERCENTAGE = 11;
+const TOKEN_DIMENSION = 12;
+const TOKEN_WHITESPACE = 13;
+const TOKEN_CDO = 14;
+const TOKEN_CDC = 15;
+const TOKEN_COLON = 16;
+const TOKEN_SEMICOLON = 17;
+const TOKEN_COMMA = 18;
+const TOKEN_LEFT_BRACKET = 19;
+const TOKEN_RIGHT_BRACKET = 20;
+const TOKEN_LEFT_PAREN = 21;
+const TOKEN_RIGHT_PAREN = 22;
+const TOKEN_LEFT_BRACE = 23;
+const TOKEN_RIGHT_BRACE = 24;
+const TOKEN_COMMENT = 25;
+const TOKEN_EOF = 26;
+const TOKEN_UNICODE_RANGE = 27;
+//#endregion
+//#region src/tokenize.ts
+function is_newline(ch) {
+	return ch < 128 && (char_types[ch] & 16) !== 0;
+}
+const CHAR_LEFT_BRACE = 123;
+const CHAR_RIGHT_BRACE = 125;
+const CHAR_COLON = 58;
+const CHAR_SEMICOLON = 59;
+const CHAR_COMMA = 44;
+const CHAR_LEFT_BRACKET = 91;
+const CHAR_RIGHT_BRACKET = 93;
+const CHAR_LEFT_PAREN = 40;
+const CHAR_RIGHT_PAREN = 41;
+const CHAR_FORWARD_SLASH = 47;
+const CHAR_ASTERISK = 42;
+const CHAR_DOUBLE_QUOTE = 34;
+const CHAR_SINGLE_QUOTE = 39;
+const CHAR_DOT = 46;
+const CHAR_LESS_THAN = 60;
+const CHAR_EXCLAMATION = 33;
+const CHAR_HYPHEN = 45;
+const CHAR_GREATER_THAN = 62;
+const CHAR_AT_SIGN = 64;
+const CHAR_HASH = 35;
+const CHAR_BACKSLASH = 92;
+const CHAR_PLUS = 43;
+const CHAR_PERCENT = 37;
+const CHAR_LOWERCASE_E = 101;
+const CHAR_UPPERCASE_E = 69;
+const CHAR_LOWERCASE_U = 117;
+const CHAR_UPPERCASE_U = 85;
+const CHAR_QUESTION_MARK = 63;
+const CHAR_CARRIAGE_RETURN = 13;
+const CHAR_LINE_FEED = 10;
+/** @internal */
+var Lexer = class {
+	source;
+	pos;
+	_line;
+	_line_offset;
+	on_comment;
+	token_type;
+	token_start;
+	token_end;
+	token_line;
+	token_column;
+	constructor(source, on_comment) {
+		this.source = source;
+		this.pos = 0;
+		this._line = 1;
+		this._line_offset = 0;
+		this.on_comment = on_comment;
+		this.token_type = 26;
+		this.token_start = 0;
+		this.token_end = 0;
+		this.token_line = 1;
+		this.token_column = 1;
+	}
+	get line() {
+		return this._line;
+	}
+	get column() {
+		return this.pos - this._line_offset + 1;
+	}
+	seek(pos, line, column = 1) {
+		this.pos = pos;
+		this._line = line;
+		this._line_offset = pos - column + 1;
+	}
+	next_token_fast(skip_whitespace = false) {
+		if (skip_whitespace) while (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch >= 128 || (char_types[ch] & 24) === 0) break;
+			this.advance();
+		}
+		if (this.pos >= this.source.length) return this.make_token(26, this.pos, this.pos);
+		let ch = this.source.charCodeAt(this.pos);
+		let start = this.pos;
+		let start_line = this.line;
+		let start_column = this.column;
+		switch (ch) {
+			case CHAR_LEFT_BRACE:
+				this.advance();
+				return this.make_token(23, start, this.pos, start_line, start_column);
+			case CHAR_RIGHT_BRACE:
+				this.advance();
+				return this.make_token(24, start, this.pos, start_line, start_column);
+			case CHAR_COLON:
+				this.advance();
+				return this.make_token(16, start, this.pos, start_line, start_column);
+			case CHAR_SEMICOLON:
+				this.advance();
+				return this.make_token(17, start, this.pos, start_line, start_column);
+			case CHAR_COMMA:
+				this.advance();
+				return this.make_token(18, start, this.pos, start_line, start_column);
+			case CHAR_LEFT_BRACKET:
+				this.advance();
+				return this.make_token(19, start, this.pos, start_line, start_column);
+			case CHAR_RIGHT_BRACKET:
+				this.advance();
+				return this.make_token(20, start, this.pos, start_line, start_column);
+			case CHAR_LEFT_PAREN:
+				this.advance();
+				return this.make_token(21, start, this.pos, start_line, start_column);
+			case CHAR_RIGHT_PAREN:
+				this.advance();
+				return this.make_token(22, start, this.pos, start_line, start_column);
+		}
+		if (ch < 128 && (char_types[ch] & 24) !== 0) return this.consume_whitespace(start_line, start_column);
+		if (ch === CHAR_FORWARD_SLASH && this.peek() === CHAR_ASTERISK) {
+			let comment_start = start;
+			let comment_line = start_line;
+			let comment_column = start_column;
+			this.advance(2);
+			while (this.pos < this.source.length - 1) {
+				if (this.source.charCodeAt(this.pos) === CHAR_ASTERISK && this.peek() === CHAR_FORWARD_SLASH) {
+					this.advance(2);
+					break;
+				}
+				this.advance();
+			}
+			let comment_end = this.pos;
+			if (this.on_comment) this.on_comment({
+				start: comment_start,
+				end: comment_end,
+				length: comment_end - comment_start,
+				line: comment_line,
+				column: comment_column
+			});
+			return this.next_token_fast(skip_whitespace);
+		}
+		if (ch === CHAR_DOUBLE_QUOTE || ch === CHAR_SINGLE_QUOTE) return this.consume_string(ch, start_line, start_column);
+		if (ch < 128 && (char_types[ch] & 2) !== 0) return this.consume_number(start_line, start_column);
+		if (ch === CHAR_DOT) {
+			let next = this.peek();
+			if (next < 128 && (char_types[next] & 2) !== 0) return this.consume_number(start_line, start_column);
+		}
+		if (ch === CHAR_LESS_THAN && this.pos + 3 < this.source.length) {
+			if (this.peek() === CHAR_EXCLAMATION && this.peek(2) === CHAR_HYPHEN && this.peek(3) === CHAR_HYPHEN) {
+				this.advance(4);
+				return this.make_token(14, start, this.pos, start_line, start_column);
+			}
+		}
+		if (ch === CHAR_HYPHEN && this.pos + 2 < this.source.length) {
+			if (this.peek() === CHAR_HYPHEN && this.peek(2) === CHAR_GREATER_THAN) {
+				this.advance(3);
+				return this.make_token(15, start, this.pos, start_line, start_column);
+			}
+		}
+		if (ch === CHAR_AT_SIGN) return this.consume_at_keyword(start_line, start_column);
+		if (ch === CHAR_HASH) return this.consume_hash(start_line, start_column);
+		if (is_ident_start(ch)) return this.consume_ident_or_function(start_line, start_column);
+		if (ch === CHAR_HYPHEN) {
+			let next = this.peek();
+			if (is_ident_start(next) || next === CHAR_HYPHEN) return this.consume_ident_or_function(start_line, start_column);
+		}
+		if (ch === CHAR_BACKSLASH) {
+			let next = this.peek();
+			if (next !== 0 && !is_newline(next)) return this.consume_ident_or_function(start_line, start_column);
+		}
+		if (ch === CHAR_HYPHEN || ch === CHAR_PLUS) {
+			let next = this.peek();
+			if (next < 128 && (char_types[next] & 2) !== 0) return this.consume_number(start_line, start_column);
+			if (next === CHAR_DOT) {
+				let next2 = this.peek(2);
+				if (next2 < 128 && (char_types[next2] & 2) !== 0) return this.consume_number(start_line, start_column);
+			}
+		}
+		this.advance();
+		return this.make_token(9, start, this.pos, start_line, start_column);
+	}
+	consume_whitespace(start_line, start_column) {
+		let start = this.pos;
+		while (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch >= 128 || (char_types[ch] & 24) === 0) break;
+			this.advance();
+		}
+		return this.make_token(13, start, this.pos, start_line, start_column);
+	}
+	consume_string(quote, start_line, start_column) {
+		let start = this.pos;
+		this.advance();
+		while (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch === quote) {
+				this.advance();
+				return this.make_token(5, start, this.pos, start_line, start_column);
+			}
+			if (is_newline(ch)) return this.make_token(6, start, this.pos, start_line, start_column);
+			if (ch === CHAR_BACKSLASH) {
+				this.advance();
+				if (this.pos < this.source.length) {
+					let next = this.source.charCodeAt(this.pos);
+					if (is_hex_digit(next)) this.consume_hex_escape();
+					else if (!is_newline(next)) this.advance();
+					else this.advance();
+				}
+				continue;
+			}
+			this.advance();
+		}
+		return this.make_token(6, start, this.pos, start_line, start_column);
+	}
+	consume_hex_escape() {
+		let count = 0;
+		while (count < 6 && this.pos < this.source.length) {
+			if (!is_hex_digit(this.source.charCodeAt(this.pos))) break;
+			this.advance();
+			count++;
+		}
+		if (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (is_whitespace(ch) || is_newline(ch)) this.advance();
+		}
+	}
+	consume_number(start_line, start_column) {
+		let start = this.pos;
+		let ch = this.source.charCodeAt(this.pos);
+		if (ch === CHAR_PLUS || ch === CHAR_HYPHEN) this.advance();
+		while (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch >= 128 || (char_types[ch] & 2) === 0) break;
+			this.advance();
+		}
+		if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_DOT && this.pos + 1 < this.source.length) {
+			let next = this.peek();
+			if (next < 128 && (char_types[next] & 2) !== 0) {
+				this.advance();
+				while (this.pos < this.source.length) {
+					let ch = this.source.charCodeAt(this.pos);
+					if (ch >= 128 || (char_types[ch] & 2) === 0) break;
+					this.advance();
+				}
+			}
+		}
+		if (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch === CHAR_LOWERCASE_E || ch === CHAR_UPPERCASE_E) {
+				let next = this.peek();
+				let is_next_digit = next < 128 && (char_types[next] & 2) !== 0;
+				let next2 = this.peek(2);
+				let is_next2_digit = next2 < 128 && (char_types[next2] & 2) !== 0;
+				if (is_next_digit || (next === CHAR_PLUS || next === CHAR_HYPHEN) && is_next2_digit) {
+					this.advance();
+					if (this.pos < this.source.length) {
+						let sign = this.source.charCodeAt(this.pos);
+						if (sign === CHAR_PLUS || sign === CHAR_HYPHEN) this.advance();
+					}
+					while (this.pos < this.source.length) {
+						let ch = this.source.charCodeAt(this.pos);
+						if (ch >= 128 || (char_types[ch] & 2) === 0) break;
+						this.advance();
+					}
+				}
+			}
+		}
+		if (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch === CHAR_PERCENT) {
+				this.advance();
+				return this.make_token(11, start, this.pos, start_line, start_column);
+			}
+			if (is_ident_start(ch) || ch === CHAR_HYPHEN && is_ident_start(this.peek())) {
+				while (this.pos < this.source.length) {
+					let ch = this.source.charCodeAt(this.pos);
+					if (ch < 128 && (char_types[ch] & 32) === 0) break;
+					this.advance();
+				}
+				return this.make_token(12, start, this.pos, start_line, start_column);
+			}
+		}
+		return this.make_token(10, start, this.pos, start_line, start_column);
+	}
+	consume_ident_or_function(start_line, start_column) {
+		let start = this.pos;
+		while (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch === CHAR_BACKSLASH) {
+				if (this.pos + 1 >= this.source.length) break;
+				let next = this.peek();
+				if (is_newline(next)) break;
+				this.advance();
+				if (is_hex_digit(next)) {
+					this.advance();
+					for (let i = 0; i < 5 && this.pos < this.source.length; i++) {
+						if (!is_hex_digit(this.source.charCodeAt(this.pos))) break;
+						this.advance();
+					}
+					if (this.pos < this.source.length) {
+						let ws = this.source.charCodeAt(this.pos);
+						if (is_whitespace(ws) || is_newline(ws)) this.advance();
+					}
+				} else this.advance();
+			} else if (ch >= 128 || (char_types[ch] & 32) !== 0) this.advance();
+			else break;
+		}
+		if (this.pos - start === 1) {
+			let first_ch = this.source.charCodeAt(start);
+			if ((first_ch === CHAR_LOWERCASE_U || first_ch === CHAR_UPPERCASE_U) && this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_PLUS) return this.consume_unicode_range(start, start_line, start_column);
+		}
+		if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LEFT_PAREN) {
+			this.advance();
+			return this.make_token(2, start, this.pos, start_line, start_column);
+		}
+		return this.make_token(1, start, this.pos, start_line, start_column);
+	}
+	consume_unicode_range(start, start_line, start_column) {
+		this.advance();
+		let hex_digits = 0;
+		let has_question = false;
+		while (this.pos < this.source.length && hex_digits < 6) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (is_hex_digit(ch)) {
+				if (has_question) break;
+				this.advance();
+				hex_digits++;
+			} else if (ch === CHAR_QUESTION_MARK) {
+				this.advance();
+				hex_digits++;
+				has_question = true;
+			} else break;
+		}
+		if (has_question) return this.make_token(27, start, this.pos, start_line, start_column);
+		if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_HYPHEN) {
+			if (this.pos + 1 < this.source.length && is_hex_digit(this.source.charCodeAt(this.pos + 1))) {
+				this.advance();
+				let end_hex_digits = 0;
+				while (this.pos < this.source.length && end_hex_digits < 6) if (is_hex_digit(this.source.charCodeAt(this.pos))) {
+					this.advance();
+					end_hex_digits++;
+				} else break;
+			}
+		}
+		return this.make_token(27, start, this.pos, start_line, start_column);
+	}
+	consume_at_keyword(start_line, start_column) {
+		let start = this.pos;
+		this.advance();
+		while (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch < 128 && (char_types[ch] & 32) === 0) break;
+			this.advance();
+		}
+		return this.make_token(3, start, this.pos, start_line, start_column);
+	}
+	consume_hash(start_line, start_column) {
+		let start = this.pos;
+		this.advance();
+		while (this.pos < this.source.length) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (ch < 128 && (char_types[ch] & 32) === 0) break;
+			this.advance();
+		}
+		return this.make_token(4, start, this.pos, start_line, start_column);
+	}
+	advance(count = 1) {
+		if (count === 1) {
+			if (this.pos >= this.source.length) return;
+			let ch = this.source.charCodeAt(this.pos);
+			this.pos++;
+			if (ch < 128 && (char_types[ch] & 16) !== 0) {
+				if (ch === CHAR_CARRIAGE_RETURN && this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LINE_FEED) this.pos++;
+				this._line++;
+				this._line_offset = this.pos;
+			}
+			return;
+		}
+		for (let i = 0; i < count; i++) {
+			if (this.pos >= this.source.length) break;
+			let ch = this.source.charCodeAt(this.pos);
+			this.pos++;
+			if (ch < 128 && (char_types[ch] & 16) !== 0) {
+				if (ch === CHAR_CARRIAGE_RETURN && this.pos < this.source.length && this.source.charCodeAt(this.pos) === CHAR_LINE_FEED) {
+					this.pos++;
+					i++;
+				}
+				this._line++;
+				this._line_offset = this.pos;
+			}
+		}
+	}
+	peek(offset = 1) {
+		let index = this.pos + offset;
+		if (index >= this.source.length) return 0;
+		return this.source.charCodeAt(index);
+	}
+	make_token(type, start, end, line = this.line, column = this.column) {
+		this.token_type = type;
+		this.token_start = start;
+		this.token_end = end;
+		this.token_line = line;
+		this.token_column = column;
+		return type;
+	}
+	next_token(skip_whitespace = false) {
+		this.next_token_fast(skip_whitespace);
+		return {
+			type: this.token_type,
+			start: this.token_start,
+			end: this.token_end,
+			line: this.token_line,
+			column: this.token_column
+		};
+	}
+	/**
+	* Save complete lexer state for backtracking
+	* @returns Object containing all lexer state
+	*/
+	save_position() {
+		return {
+			pos: this.pos,
+			line: this._line,
+			column: this.column,
+			_line_offset: this._line_offset,
+			token_type: this.token_type,
+			token_start: this.token_start,
+			token_end: this.token_end,
+			token_line: this.token_line,
+			token_column: this.token_column
+		};
+	}
+	/**
+	* Restore lexer state from saved position
+	* @param saved The saved position to restore
+	*/
+	restore_position(saved) {
+		this.pos = saved.pos;
+		this._line = saved.line;
+		this._line_offset = saved._line_offset;
+		this.token_type = saved.token_type;
+		this.token_start = saved.token_start;
+		this.token_end = saved.token_end;
+		this.token_line = saved.token_line;
+		this.token_column = saved.token_column;
+	}
+	/**
+	* Skip whitespace and comments within a range, maintaining line/column tracking
+	* @param end The end boundary (exclusive)
+	*/
+	skip_whitespace_in_range(end) {
+		while (this.pos < end) {
+			let ch = this.source.charCodeAt(this.pos);
+			if (is_whitespace(ch)) {
+				this.advance();
+				continue;
+			}
+			if (ch === CHAR_FORWARD_SLASH && this.pos + 1 < end && this.source.charCodeAt(this.pos + 1) === CHAR_ASTERISK) {
+				this.advance();
+				this.advance();
+				while (this.pos < end) {
+					if (this.source.charCodeAt(this.pos) === CHAR_ASTERISK && this.pos + 1 < end && this.source.charCodeAt(this.pos + 1) === CHAR_FORWARD_SLASH) {
+						this.advance();
+						this.advance();
+						break;
+					}
+					this.advance();
+				}
+				continue;
+			}
+			break;
+		}
+	}
+};
+/**
+* Tokenize CSS source code
+* @param source - The CSS source code to tokenize
+* @param on_comment - Optional callback for comment tokens
+* @yields CSS tokens
+*/
+function* tokenize(source, on_comment) {
+	const lexer = new Lexer(source, on_comment);
+	while (true) {
+		const token = lexer.next_token();
+		if (!token || token.type === 26) break;
+		yield token;
+	}
+}
+//#endregion
+export { TOKEN_RIGHT_BRACKET as C, TOKEN_UNICODE_RANGE as D, TOKEN_STRING as E, TOKEN_URL as O, TOKEN_RIGHT_BRACE as S, TOKEN_SEMICOLON as T, TOKEN_LEFT_BRACE as _, TOKEN_BAD_URL as a, TOKEN_NUMBER as b, TOKEN_COLON as c, TOKEN_DELIM as d, TOKEN_DIMENSION as f, TOKEN_IDENT as g, TOKEN_HASH as h, TOKEN_BAD_STRING as i, TOKEN_WHITESPACE as k, TOKEN_COMMA as l, TOKEN_FUNCTION as m, tokenize as n, TOKEN_CDC as o, TOKEN_EOF as p, TOKEN_AT_KEYWORD as r, TOKEN_CDO as s, Lexer as t, TOKEN_COMMENT as u, TOKEN_LEFT_BRACKET as v, TOKEN_RIGHT_PAREN as w, TOKEN_PERCENTAGE as x, TOKEN_LEFT_PAREN as y };

package/dist/tokenize-odLrcjj2.d.ts

@@ -0,0 +1,110 @@
+//#region src/token-types.d.ts
+declare const TOKEN_IDENT = 1;
+declare const TOKEN_FUNCTION = 2;
+declare const TOKEN_AT_KEYWORD = 3;
+declare const TOKEN_HASH = 4;
+declare const TOKEN_STRING = 5;
+declare const TOKEN_BAD_STRING = 6;
+declare const TOKEN_URL = 7;
+declare const TOKEN_BAD_URL = 8;
+declare const TOKEN_DELIM = 9;
+declare const TOKEN_NUMBER = 10;
+declare const TOKEN_PERCENTAGE = 11;
+declare const TOKEN_DIMENSION = 12;
+declare const TOKEN_WHITESPACE = 13;
+declare const TOKEN_CDO = 14;
+declare const TOKEN_CDC = 15;
+declare const TOKEN_COLON = 16;
+declare const TOKEN_SEMICOLON = 17;
+declare const TOKEN_COMMA = 18;
+declare const TOKEN_LEFT_BRACKET = 19;
+declare const TOKEN_RIGHT_BRACKET = 20;
+declare const TOKEN_LEFT_PAREN = 21;
+declare const TOKEN_RIGHT_PAREN = 22;
+declare const TOKEN_LEFT_BRACE = 23;
+declare const TOKEN_RIGHT_BRACE = 24;
+declare const TOKEN_COMMENT = 25;
+declare const TOKEN_EOF = 26;
+declare const TOKEN_UNICODE_RANGE = 27;
+type TokenType = typeof TOKEN_IDENT | typeof TOKEN_FUNCTION | typeof TOKEN_AT_KEYWORD | typeof TOKEN_HASH | typeof TOKEN_STRING | typeof TOKEN_BAD_STRING | typeof TOKEN_URL | typeof TOKEN_BAD_URL | typeof TOKEN_DELIM | typeof TOKEN_NUMBER | typeof TOKEN_PERCENTAGE | typeof TOKEN_DIMENSION | typeof TOKEN_WHITESPACE | typeof TOKEN_CDO | typeof TOKEN_CDC | typeof TOKEN_COLON | typeof TOKEN_SEMICOLON | typeof TOKEN_COMMA | typeof TOKEN_LEFT_BRACKET | typeof TOKEN_RIGHT_BRACKET | typeof TOKEN_LEFT_PAREN | typeof TOKEN_RIGHT_PAREN | typeof TOKEN_LEFT_BRACE | typeof TOKEN_RIGHT_BRACE | typeof TOKEN_COMMENT | typeof TOKEN_EOF | typeof TOKEN_UNICODE_RANGE;
+type Token = {
+  type: TokenType;
+  start: number;
+  end: number;
+  line: number;
+  column: number;
+};
+//#endregion
+//#region src/tokenize.d.ts
+interface LexerPosition {
+  pos: number;
+  line: number;
+  column: number;
+  _line_offset: number;
+  token_type: TokenType;
+  token_start: number;
+  token_end: number;
+  token_line: number;
+  token_column: number;
+}
+interface CommentInfo {
+  start: number;
+  end: number;
+  length: number;
+  line: number;
+  column: number;
+}
+/** @internal */
+declare class Lexer {
+  source: string;
+  pos: number;
+  private _line;
+  private _line_offset;
+  on_comment: ((info: CommentInfo) => void) | undefined;
+  token_type: TokenType;
+  token_start: number;
+  token_end: number;
+  token_line: number;
+  token_column: number;
+  constructor(source: string, on_comment?: (info: CommentInfo) => void);
+  get line(): number;
+  get column(): number;
+  seek(pos: number, line: number, column?: number): void;
+  next_token_fast(skip_whitespace?: boolean): TokenType;
+  consume_whitespace(start_line: number, start_column: number): TokenType;
+  consume_string(quote: number, start_line: number, start_column: number): TokenType;
+  consume_hex_escape(): void;
+  consume_number(start_line: number, start_column: number): TokenType;
+  consume_ident_or_function(start_line: number, start_column: number): TokenType;
+  consume_unicode_range(start: number, start_line: number, start_column: number): TokenType;
+  consume_at_keyword(start_line: number, start_column: number): TokenType;
+  consume_hash(start_line: number, start_column: number): TokenType;
+  advance(count?: number): void;
+  peek(offset?: number): number;
+  make_token(type: TokenType, start: number, end: number, line?: number, column?: number): TokenType;
+  next_token(skip_whitespace?: boolean): Token | null;
+  /**
+   * Save complete lexer state for backtracking
+   * @returns Object containing all lexer state
+   */
+  save_position(): LexerPosition;
+  /**
+   * Restore lexer state from saved position
+   * @param saved The saved position to restore
+   */
+  restore_position(saved: LexerPosition): void;
+  /**
+   * Skip whitespace and comments within a range, maintaining line/column tracking
+   * @param end The end boundary (exclusive)
+   */
+  skip_whitespace_in_range(end: number): void;
+}
+/**
+ * Tokenize CSS source code
+ * @param source - The CSS source code to tokenize
+ * @param on_comment - Optional callback for comment tokens
+ * @yields CSS tokens
+ */
+declare function tokenize(source: string, on_comment?: (info: CommentInfo) => void): Generator<Token, void, undefined>;
+//#endregion
+export { TOKEN_URL as A, TOKEN_PERCENTAGE as C, TOKEN_SEMICOLON as D, TOKEN_RIGHT_PAREN as E, Token as M, TokenType as N, TOKEN_STRING as O, TOKEN_NUMBER as S, TOKEN_RIGHT_BRACKET as T, TOKEN_HASH as _, TOKEN_AT_KEYWORD as a, TOKEN_LEFT_BRACKET as b, TOKEN_CDC as c, TOKEN_COMMA as d, TOKEN_COMMENT as f, TOKEN_FUNCTION as g, TOKEN_EOF as h, tokenize as i, TOKEN_WHITESPACE as j, TOKEN_UNICODE_RANGE as k, TOKEN_CDO as l, TOKEN_DIMENSION as m, Lexer as n, TOKEN_BAD_STRING as o, TOKEN_DELIM as p, LexerPosition as r, TOKEN_BAD_URL as s, CommentInfo as t, TOKEN_COLON as u, TOKEN_IDENT as v, TOKEN_RIGHT_BRACE as w, TOKEN_LEFT_PAREN as x, TOKEN_LEFT_BRACE as y };

package/dist/tokenize.d.ts

@@ -1,26 +1,2 @@
-import { type Token, type TokenType } from './token-types';
-export interface LexerPosition {
-    pos: number;
-    line: number;
-    column: number;
-    _line_offset: number;
-    token_type: TokenType;
-    token_start: number;
-    token_end: number;
-    token_line: number;
-    token_column: number;
-}
-export interface CommentInfo {
-    start: number;
-    end: number;
-    length: number;
-    line: number;
-    column: number;
-}
-/**
- * Tokenize CSS source code
- * @param source - The CSS source code to tokenize
- * @param on_comment - Optional callback for comment tokens
- * @yields CSS tokens
- */
-export declare function tokenize(source: string, on_comment?: (info: CommentInfo) => void): Generator<Token, void, undefined>;
+import { i as tokenize, n as Lexer, r as LexerPosition, t as CommentInfo } from "./tokenize-odLrcjj2.js";
+export { CommentInfo, Lexer, LexerPosition, tokenize };