@lass-lang/core 0.0.1

package/dist/scanner.js

@@ -0,0 +1,815 @@
+/**
+ * Single-pass text scanner for Lass language.
+ *
+ * The scanner processes input in a single pass. It does NOT parse CSS - it
+ * only scans for Lass symbols within CSS text.
+ *
+ * Story 1.4: Passthrough-only
+ * Story 2.1: Zone detection (--- separator)
+ */
+import { LassTranspileError, ErrorCategory } from './errors.js';
+import { createContextState, updateContextState, isInProtectedContext } from './context-tracker.js';
+/**
+ * Single-pass text scanner for Lass language.
+ *
+ * Story 1.4: Passthrough mode - returns input unchanged
+ * Story 2.1: Zone detection - finds --- separator, splits into preamble/CSS
+ * Story 3.2: @(prop) detection - finds property accessors in value position
+ *
+ * Future implementations will:
+ * - Detect $name, $(name), {{ expr }}, @{ } symbols
+ * - Track context to skip symbols inside strings, urls, and comments
+ */
+export class Scanner {
+    source;
+    constructor(source, _options = {}) {
+        this.source = source;
+        // Note: options.filename is accepted for API compatibility but not yet used
+        // Future: include filename in error messages for better debugging
+    }
+    /**
+     * Finds the --- separator and splits source into preamble and CSS zones.
+     *
+     * Story 2.1: Zone detection
+     *
+     * Rules:
+     * - Separator must be exactly "---" at column 0 (start of line)
+     * - May have trailing whitespace
+     * - Must NOT be inside a multi-line comment (slash-star ... star-slash)
+     * - Only one separator allowed per file
+     *
+     * Note: Line endings are normalized to \n during processing.
+     * When no separator is found, cssZone returns the original source unchanged.
+     *
+     * @returns Zone split result with preamble, cssZone, and hasSeparator
+     * @throws LassTranspileError if multiple separators found
+     */
+    findSeparator() {
+        // Normalize line endings to \n for consistent processing
+        const normalized = this.source.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const lines = normalized.split('\n');
+        let separatorLineIndex = -1;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            // Check if this line is the separator (only if not inside a block comment)
+            if (!this.isInBlockComment(lines, i) && this.isSeparatorLine(line)) {
+                if (separatorLineIndex !== -1) {
+                    // Multiple separators found
+                    throw LassTranspileError.at('Multiple --- separators found. Only one is allowed per file.', ErrorCategory.SCAN, i + 1, 1, this.getOffset(lines, i));
+                }
+                separatorLineIndex = i;
+            }
+        }
+        if (separatorLineIndex === -1) {
+            // No separator - entire file is CSS zone
+            return {
+                preamble: '',
+                cssZone: this.source,
+                hasSeparator: false,
+            };
+        }
+        // Split at separator
+        const preambleLines = lines.slice(0, separatorLineIndex);
+        const cssLines = lines.slice(separatorLineIndex + 1);
+        return {
+            preamble: preambleLines.join('\n'),
+            cssZone: cssLines.join('\n'),
+            hasSeparator: true,
+        };
+    }
+    /**
+     * Checks if a line is the --- separator.
+     * Must be exactly "---" with optional trailing whitespace.
+     */
+    isSeparatorLine(line) {
+        // Must start with exactly "---" (no leading whitespace)
+        // May have trailing whitespace
+        return /^---\s*$/.test(line);
+    }
+    /**
+     * Checks if line at index is inside a block comment.
+     * Scans from start of file to determine comment state at the START of the line.
+     */
+    isInBlockComment(lines, targetLineIndex) {
+        let inComment = false;
+        for (let i = 0; i < targetLineIndex; i++) {
+            const line = lines[i];
+            let j = 0;
+            while (j < line.length) {
+                if (inComment) {
+                    const endIdx = line.indexOf('*/', j);
+                    if (endIdx !== -1) {
+                        inComment = false;
+                        j = endIdx + 2;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                else {
+                    const startIdx = line.indexOf('/*', j);
+                    if (startIdx !== -1) {
+                        inComment = true;
+                        j = startIdx + 2;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+        }
+        // Also check if comment started on a previous line and extends to current line
+        // At this point, inComment tells us if we're in a comment at the START of targetLineIndex
+        return inComment;
+    }
+    /**
+     * Calculates character offset for a given line.
+     */
+    getOffset(lines, lineIndex) {
+        let offset = 0;
+        for (let i = 0; i < lineIndex; i++) {
+            offset += lines[i].length + 1; // +1 for newline
+        }
+        return offset;
+    }
+    /**
+     * Scans the input and returns processed CSS.
+     *
+     * In passthrough mode (Story 1.4), this returns the input unchanged.
+     *
+     * @returns Scan result with processed CSS
+     */
+    scan() {
+        // Story 1.4: Passthrough mode - return input unchanged
+        return {
+            css: this.source,
+        };
+    }
+    /**
+     * Finds {{ expr }} expressions in CSS zone and splits into alternating parts.
+     *
+     * Story 2.3: Expression interpolation
+     * Story 2.5: Universal {{ }} processing - works EVERYWHERE in CSS zone
+     *
+     * Returns alternating CSS chunks and JS expressions:
+     * - [css, expr, css, expr, css] - always starts and ends with CSS (possibly empty)
+     * - Expression content is trimmed of leading/trailing whitespace
+     *
+     * Handles nested braces in expressions (e.g., {{ fn({x:1}) }}) by tracking brace depth.
+     *
+     * Universal processing: {{ }} is detected and processed in ALL contexts:
+     * - Value position: `color: {{ x }};`
+     * - Inside strings: `content: "Hello {{ name }}!";`
+     * - Inside url(): `background: url("{{ path }}.jpg");`
+     * - Inside comments: `/* Version: {{ version }} *‍/`
+     *
+     * @param cssZone - The CSS zone content to scan
+     * @returns ExpressionSplit with parts and expression positions
+     * @throws LassTranspileError for empty or unclosed expressions
+     */
+    findExpressions(cssZone) {
+        const parts = [];
+        const expressionPositions = [];
+        let currentPos = 0;
+        let cssStart = 0;
+        while (currentPos < cssZone.length) {
+            // Find next {{ using simple indexOf - process everywhere in CSS zone
+            const openPos = cssZone.indexOf('{{', currentPos);
+            if (openPos === -1) {
+                // No more expressions - add remaining CSS
+                parts.push(cssZone.slice(cssStart));
+                break;
+            }
+            // Found {{ - add CSS chunk before it
+            parts.push(cssZone.slice(cssStart, openPos));
+            expressionPositions.push(openPos);
+            // Find matching }} with brace depth tracking
+            const exprStart = openPos + 2;
+            let braceDepth = 0;
+            let closePos = -1;
+            for (let j = exprStart; j < cssZone.length - 1; j++) {
+                const char = cssZone[j];
+                if (char === '{') {
+                    braceDepth++;
+                }
+                else if (char === '}') {
+                    if (braceDepth === 0 && cssZone[j + 1] === '}') {
+                        // Found matching }}
+                        closePos = j;
+                        break;
+                    }
+                    braceDepth--;
+                }
+            }
+            if (closePos === -1) {
+                // Unclosed expression
+                const line = this.getLineNumber(cssZone, openPos);
+                const col = this.getColumnNumber(cssZone, openPos);
+                throw LassTranspileError.at('Unclosed {{ expression', ErrorCategory.SCAN, line, col, openPos);
+            }
+            // Extract and trim expression content
+            const exprContent = cssZone.slice(exprStart, closePos).trim();
+            if (exprContent === '') {
+                // Empty expression
+                const line = this.getLineNumber(cssZone, openPos);
+                const col = this.getColumnNumber(cssZone, openPos);
+                throw LassTranspileError.at('Empty {{ }} expression', ErrorCategory.SCAN, line, col, openPos);
+            }
+            parts.push(exprContent);
+            // Move past }}
+            currentPos = closePos + 2;
+            cssStart = currentPos;
+        }
+        // Ensure we always end with a CSS part (even if empty)
+        if (parts.length > 0 && parts.length % 2 === 0) {
+            parts.push('');
+        }
+        // Handle case where no expressions were found and we didn't add anything
+        if (parts.length === 0) {
+            parts.push(cssZone);
+        }
+        return { parts, expressionPositions };
+    }
+    /**
+     * Gets the 1-based line number for a character offset.
+     */
+    getLineNumber(text, offset) {
+        let line = 1;
+        for (let i = 0; i < offset && i < text.length; i++) {
+            if (text[i] === '\n')
+                line++;
+        }
+        return line;
+    }
+    /**
+     * Gets the 1-based column number for a character offset.
+     */
+    getColumnNumber(text, offset) {
+        let col = 1;
+        for (let i = offset - 1; i >= 0 && text[i] !== '\n'; i--) {
+            col++;
+        }
+        return col;
+    }
+    /**
+     * Known CSS at-rules - kept for reference but not needed for @(prop) detection.
+     * The @(prop) syntax with parentheses is unambiguous - no collision with CSS at-rules.
+     */
+    static CSS_AT_RULES = new Set([
+        'media',
+        'layer',
+        'supports',
+        'container',
+        'keyframes',
+        'font-face',
+        'import',
+        'charset',
+        'namespace',
+        'page',
+        'counter-style',
+        'font-feature-values',
+        'property',
+        'scope',
+        'starting-style',
+    ]);
+    /**
+     * Finds @(prop) accessors in CSS zone.
+     *
+     * Story 3.2: Basic Property Lookup
+     * Refactored: Changed from @prop to @(prop) for unambiguous syntax
+     *
+     * Detection rules:
+     * - @(propname) in CSS value position (after :) is a Lass accessor
+     * - The explicit parentheses make this unambiguous - no collision with CSS at-rules
+     * - Supports both standard properties and custom properties: @(border), @(--custom)
+     *
+     * Valid CSS property names inside @():
+     * - Standard: letter or hyphen start, then letters/digits/hyphens
+     * - Custom: -- followed by letters/digits/hyphens
+     *
+     * @param cssZone - The CSS zone content to scan
+     * @returns Array of PropertyAccessor objects with propName and indices
+     */
+    findPropertyAccessors(cssZone) {
+        return Scanner.findPropertyAccessorsStatic(cssZone);
+    }
+    /**
+     * Static version of findPropertyAccessors for use without Scanner instantiation.
+     * Used internally by transpiler to avoid creating unnecessary Scanner instances.
+     *
+     * Story 3.3: Handles @(prop) inside {{ }} expressions.
+     * - {{ doesn't reset inValuePosition (JS expression can contain @(prop))
+     * - }} doesn't reset inValuePosition (exiting expression, still in value)
+     * - Single { resets inValuePosition (entering CSS block)
+     * - @(prop) inside {{ }} is detected and will be quoted during resolution
+     *
+     * Refactored: Changed from @prop to @(prop) for unambiguous syntax.
+     * This eliminates ambiguity in JS context: @(border-width) is clear,
+     * unlike @border-width which could be @border minus width.
+     *
+     * @param cssZone - The CSS zone content to scan
+     * @returns Array of PropertyAccessor objects with propName and indices
+     */
+    static findPropertyAccessorsStatic(cssZone) {
+        const accessors = [];
+        if (!cssZone) {
+            return accessors;
+        }
+        // Pattern for property name inside @():
+        // - Standard property: letter or hyphen start, then letters/digits/hyphens
+        // - Custom property: -- followed by letters/digits/hyphens
+        const propNamePattern = /^([a-zA-Z-][a-zA-Z0-9-]*|--[a-zA-Z0-9-]+)/;
+        // Track if we're in value position (after :)
+        let inValuePosition = false;
+        // Track expression depth for {{ }} (Story 3.3)
+        let expressionDepth = 0;
+        let i = 0;
+        while (i < cssZone.length) {
+            const char = cssZone[i];
+            const nextChar = cssZone[i + 1];
+            // Track colon for value position
+            if (char === ':') {
+                inValuePosition = true;
+                i++;
+                continue;
+            }
+            // Handle {{ - entering JS expression (Story 3.3)
+            // DON'T reset inValuePosition - we can have @(prop) inside expressions
+            if (char === '{' && nextChar === '{') {
+                expressionDepth++;
+                i += 2;
+                continue;
+            }
+            // Handle }} - exiting JS expression (Story 3.3)
+            // DON'T reset inValuePosition - we're still in the CSS value after expression
+            if (char === '}' && nextChar === '}') {
+                expressionDepth--;
+                i += 2;
+                continue;
+            }
+            // Reset on semicolon (end of declaration) - but only if not inside expression
+            if (char === ';' && expressionDepth === 0) {
+                inValuePosition = false;
+                i++;
+                continue;
+            }
+            // Reset on single closing brace (end of block) - but only if not inside expression
+            if (char === '}' && expressionDepth === 0) {
+                inValuePosition = false;
+                i++;
+                continue;
+            }
+            // Reset on single opening brace (entering a new CSS block) - but only if not inside expression
+            if (char === '{' && expressionDepth === 0) {
+                inValuePosition = false;
+                i++;
+                continue;
+            }
+            // Check for @( pattern - the explicit accessor syntax
+            if (char === '@' && nextChar === '(') {
+                // Find the closing parenthesis
+                const afterParen = cssZone.slice(i + 2);
+                const closeParenIdx = afterParen.indexOf(')');
+                if (closeParenIdx !== -1) {
+                    const insideParens = afterParen.slice(0, closeParenIdx);
+                    const match = insideParens.match(propNamePattern);
+                    // Check if the entire content inside parens is a valid property name
+                    if (match && match[0] === insideParens) {
+                        const propName = match[0];
+                        // Detect if we're in value position (after :)
+                        // Story 3.3: This works inside {{ }} because we don't reset inValuePosition there
+                        if (inValuePosition) {
+                            accessors.push({
+                                propName,
+                                startIndex: i,
+                                // @(propname) = @ + ( + propname + ) = 3 + propname.length
+                                endIndex: i + 3 + propName.length,
+                            });
+                        }
+                        // Move past the @(propname)
+                        i += 3 + propName.length;
+                        continue;
+                    }
+                }
+            }
+            i++;
+        }
+        return accessors;
+    }
+    /**
+     * Finds $param variables in CSS zone.
+     *
+     * Story 4.1: Variable Substitution
+     *
+     * Detection rules:
+     * - $param is detected when $ is followed by a valid JS identifier character
+     * - Valid identifier start: [a-zA-Z_$]
+     * - Valid identifier char: [a-zA-Z0-9_$]
+     * - Identifier stops at first non-identifier character (hyphen, space, ;, {, etc.)
+     * - Bare $ (not followed by valid identifier start) is treated as literal text
+     *
+     * Protected contexts (detection skipped):
+     * - Inside CSS string literals ("..." or '...')
+     * - Inside /* ... *‍/ block comments
+     *
+     * Note: url() is NOT a protected context - $param inside url() IS substituted.
+     * Use {{ $param }} bridge syntax if you need dynamic content inside strings.
+     *
+     * @param cssZone - The CSS zone content to scan
+     * @returns Array of DollarVariable objects with varName and indices
+     */
+    findDollarVariables(cssZone) {
+        return Scanner.findDollarVariablesStatic(cssZone);
+    }
+    /**
+     * Static version of findDollarVariables for use without Scanner instantiation.
+     * Used internally by transpiler to avoid creating unnecessary Scanner instances.
+     *
+     * Story 4.1: Variable Substitution
+     *
+     * @param cssZone - The CSS zone content to scan
+     * @returns Array of DollarVariable objects with varName and indices
+     */
+    static findDollarVariablesStatic(cssZone) {
+        const variables = [];
+        if (!cssZone) {
+            return variables;
+        }
+        // Context tracking for protected zones (strings, comments)
+        // Note: url() is NOT protected - $param inside url() IS substituted
+        const state = createContextState();
+        // Track {{ }} script block depth ($param not substituted inside)
+        let scriptBlockDepth = 0;
+        let i = 0;
+        while (i < cssZone.length) {
+            const char = cssZone[i];
+            const nextChar = cssZone[i + 1];
+            // Update context state (handles strings and comments)
+            const consumed = updateContextState(cssZone, i, state);
+            if (consumed === 2) {
+                i += 2;
+                continue;
+            }
+            // Skip string quote characters (already handled by updateContextState)
+            if (char === '"' || char === "'") {
+                i++;
+                continue;
+            }
+            // Track {{ }} script block depth (only when not in protected context)
+            if (!isInProtectedContext(state) && char === '{' && nextChar === '{') {
+                scriptBlockDepth++;
+                i += 2;
+                continue;
+            }
+            if (!isInProtectedContext(state) && char === '}' && nextChar === '}' && scriptBlockDepth > 0) {
+                scriptBlockDepth--;
+                i += 2;
+                continue;
+            }
+            // Skip if in any protected context OR inside {{ }}
+            if (isInProtectedContext(state) || scriptBlockDepth > 0) {
+                i++;
+                continue;
+            }
+            // Check for $ followed by valid identifier start
+            if (char === '$' && nextChar !== undefined && Scanner.isIdentifierStart(nextChar)) {
+                const startIndex = i;
+                i++; // Move past $
+                // Consume identifier characters
+                let varName = '$';
+                while (i < cssZone.length && Scanner.isIdentifierChar(cssZone[i])) {
+                    varName += cssZone[i];
+                    i++;
+                }
+                variables.push({
+                    varName,
+                    startIndex,
+                    endIndex: i,
+                });
+                continue;
+            }
+            i++;
+        }
+        return variables;
+    }
+    /**
+     * Checks if a character is a valid JS identifier start.
+     * Valid: a-z, A-Z, _, $
+     */
+    static isIdentifierStart(char) {
+        return /^[a-zA-Z_$]$/.test(char);
+    }
+    /**
+     * Checks if a character is a valid JS identifier character.
+     * Valid: a-z, A-Z, 0-9, _, $
+     */
+    static isIdentifierChar(char) {
+        return /^[a-zA-Z0-9_$]$/.test(char);
+    }
+    /**
+     * Finds @prop shorthand accessors in CSS zone.
+     *
+     * Story 4.2: Style Lookup Shorthand
+     *
+     * Detection rules:
+     * - @prop in CSS value position (after :) is a Lass shorthand accessor
+     * - @prop shorthand only works when identifier starts with a letter [a-zA-Z]
+     * - Identifier continues with letters, digits, hyphens, underscores
+     * - NOT detected inside {{ }} script blocks (use explicit @(prop) there)
+     * - NOT detected inside protected contexts: strings, comments, url()
+     *
+     * Examples:
+     * - @border → shorthand for @(border)
+     * - @border-color → shorthand for @(border-color)
+     * - @--custom → NOT detected (starts with hyphen, use @(--custom))
+     * - @-webkit-foo → NOT detected (starts with hyphen, use @(-webkit-foo))
+     *
+     * @param cssZone - The CSS zone content to scan
+     * @returns Array of StyleLookupShorthand objects with propName and indices
+     */
+    findStyleLookupShorthands(cssZone) {
+        return Scanner.findStyleLookupShorthandsStatic(cssZone);
+    }
+    /**
+     * Static version of findStyleLookupShorthands for use without Scanner instantiation.
+     * Used internally by transpiler to avoid creating unnecessary Scanner instances.
+     *
+     * Story 4.2: Style Lookup Shorthand
+     *
+     * @param cssZone - The CSS zone content to scan
+     * @returns Array of StyleLookupShorthand objects with propName and indices
+     */
+    static findStyleLookupShorthandsStatic(cssZone) {
+        const shorthands = [];
+        if (!cssZone) {
+            return shorthands;
+        }
+        // Context tracking for protected zones (strings, comments)
+        // Note: url() is NOT a protected context - @prop inside url(@path) IS detected
+        const state = createContextState();
+        const contextStack = [{ type: 'css', braceDepth: 0 }];
+        // Track if we're in value position (after :)
+        let inValuePosition = false;
+        let i = 0;
+        while (i < cssZone.length) {
+            const char = cssZone[i];
+            const nextChar = cssZone[i + 1];
+            // Update context state (handles strings and comments)
+            const consumed = updateContextState(cssZone, i, state);
+            if (consumed === 2) {
+                i += 2;
+                continue;
+            }
+            // Skip string quote characters (already handled by updateContextState)
+            if (char === '"' || char === "'") {
+                i++;
+                continue;
+            }
+            // Skip if in protected context (strings, comments)
+            if (isInProtectedContext(state)) {
+                i++;
+                continue;
+            }
+            // Track context transitions
+            const currentEntry = contextStack[contextStack.length - 1];
+            // Check for {{ - enters JS context
+            if (char === '{' && nextChar === '{') {
+                contextStack.push({ type: 'js', braceDepth: 0 });
+                i += 2;
+                continue;
+            }
+            // Check for }} - exits JS context
+            if (char === '}' && nextChar === '}') {
+                // Pop until we find a 'js' context (may need to pop @{ css first)
+                while (contextStack.length > 1 && contextStack[contextStack.length - 1].type !== 'js') {
+                    contextStack.pop();
+                }
+                if (contextStack.length > 1) {
+                    contextStack.pop(); // pop the 'js'
+                }
+                i += 2;
+                continue;
+            }
+            // Check for @{ - enters CSS context (style block inside JS)
+            if (char === '@' && nextChar === '{' && currentEntry.type === 'js') {
+                contextStack.push({ type: 'css', braceDepth: 0 });
+                i += 2;
+                continue;
+            }
+            // Track single braces within @{ CSS context (for nested CSS blocks)
+            if (currentEntry.type === 'css' && contextStack.length > 1) {
+                // We're in a @{ block (not the root CSS context)
+                if (char === '{') {
+                    currentEntry.braceDepth++;
+                    inValuePosition = false;
+                    i++;
+                    continue;
+                }
+                if (char === '}') {
+                    if (currentEntry.braceDepth > 0) {
+                        // Closing a nested CSS block within @{
+                        currentEntry.braceDepth--;
+                        inValuePosition = false;
+                    }
+                    else {
+                        // Closing the @{ block itself
+                        contextStack.pop();
+                    }
+                    i++;
+                    continue;
+                }
+            }
+            // Get current context type
+            const currentContext = contextStack[contextStack.length - 1].type;
+            // Skip if in JS context (not inside a @{ block)
+            if (currentContext === 'js') {
+                i++;
+                continue;
+            }
+            // Track colon for value position
+            if (char === ':') {
+                inValuePosition = true;
+                i++;
+                continue;
+            }
+            // Reset on semicolon (end of declaration)
+            if (char === ';') {
+                inValuePosition = false;
+                i++;
+                continue;
+            }
+            // Reset on single opening brace (entering a new CSS block)
+            if (char === '{') {
+                inValuePosition = false;
+                i++;
+                continue;
+            }
+            // Reset on single closing brace (end of block)
+            if (char === '}') {
+                inValuePosition = false;
+                i++;
+                continue;
+            }
+            // Check for @ followed by letter (shorthand only works when starting with letter)
+            if (char === '@' && nextChar !== undefined && /^[a-zA-Z]$/.test(nextChar)) {
+                // Only detect in value position
+                if (inValuePosition) {
+                    const startIndex = i;
+                    i++; // Move past @
+                    // Consume CSS identifier characters (letters, digits, hyphens, underscores)
+                    let propName = '';
+                    while (i < cssZone.length && Scanner.isCssIdentifierChar(cssZone[i])) {
+                        propName += cssZone[i];
+                        i++;
+                    }
+                    shorthands.push({
+                        propName,
+                        startIndex,
+                        endIndex: i,
+                    });
+                    continue;
+                }
+            }
+            i++;
+        }
+        return shorthands;
+    }
+    /**
+     * Checks if a character is a valid CSS identifier character.
+     * Valid: a-z, A-Z, 0-9, -, _
+     */
+    static isCssIdentifierChar(char) {
+        return /^[a-zA-Z0-9_-]$/.test(char);
+    }
+    /**
+     * Strips // single-line comments from CSS zone.
+     *
+     * Story 4.4: Single-Line Comment Stripping
+     *
+     * Detection rules:
+     * - // to end of line (including newline) is removed
+     * - Skip detection inside protected contexts: strings, url(), /* *\/
+     * - Full-line comments remove the entire line
+     * - Inline comments preserve content before //
+     *
+     * Note: url() is protected here (unlike $param/@prop) because
+     * url(https://...) contains // as part of the URL protocol.
+     *
+     * @param cssZone - The CSS zone content to process
+     * @returns CSS zone with // comments stripped
+     * @throws LassTranspileError if unclosed /* comment detected
+     */
+    stripLineComments(cssZone) {
+        return Scanner.stripLineCommentsStatic(cssZone);
+    }
+    /**
+     * Static version of stripLineComments for use without Scanner instantiation.
+     * Used internally by transpiler to avoid creating unnecessary Scanner instances.
+     *
+     * Story 4.4: Single-Line Comment Stripping
+     *
+     * @param cssZone - The CSS zone content to process
+     * @returns CSS zone with // comments stripped
+     * @throws LassTranspileError if unclosed /* comment detected
+     */
+    static stripLineCommentsStatic(cssZone) {
+        if (!cssZone) {
+            return cssZone;
+        }
+        // Context tracking for protected zones (strings, block comments)
+        const state = createContextState();
+        // Local url() tracking - unique to this function because url(https://...)
+        // contains // that should NOT be treated as a comment
+        let inUrl = false;
+        let urlParenDepth = 0;
+        // Track position where /* started (for error reporting)
+        let blockCommentStartLine = -1;
+        let blockCommentStartOffset = -1;
+        let result = '';
+        let i = 0;
+        while (i < cssZone.length) {
+            const char = cssZone[i];
+            const nextChar = cssZone[i + 1];
+            // Track block comment start position for error reporting
+            if (!state.inString && !state.inBlockComment && char === '/' && nextChar === '*') {
+                blockCommentStartLine = Scanner.getLineNumberStatic(cssZone, i);
+                blockCommentStartOffset = i;
+            }
+            // Update context state (strings, block comments)
+            const consumed = updateContextState(cssZone, i, state);
+            if (consumed === 2) {
+                result += cssZone.slice(i, i + 2);
+                i += 2;
+                continue;
+            }
+            // Handle string quote characters
+            if (char === '"' || char === "'") {
+                result += char;
+                i++;
+                continue;
+            }
+            // Track url() context (only when not in string or block comment)
+            if (!isInProtectedContext(state) && !inUrl) {
+                if (cssZone.slice(i, i + 4).toLowerCase() === 'url(') {
+                    inUrl = true;
+                    urlParenDepth = 1;
+                    result += cssZone.slice(i, i + 4);
+                    i += 4;
+                    continue;
+                }
+            }
+            // Handle characters inside url()
+            if (inUrl) {
+                if (char === '(') {
+                    urlParenDepth++;
+                }
+                else if (char === ')') {
+                    urlParenDepth--;
+                    if (urlParenDepth === 0) {
+                        inUrl = false;
+                    }
+                }
+                result += char;
+                i++;
+                continue;
+            }
+            // Skip if in any protected context (string or block comment)
+            if (isInProtectedContext(state)) {
+                result += char;
+                i++;
+                continue;
+            }
+            // Check for // line comment
+            if (char === '/' && nextChar === '/') {
+                // Find end of line (the comment is from // to just before the newline)
+                let endOfLine = i;
+                while (endOfLine < cssZone.length && cssZone[endOfLine] !== '\n' && cssZone[endOfLine] !== '\r') {
+                    endOfLine++;
+                }
+                // Skip past the comment content, stop at the newline (don't consume it)
+                i = endOfLine;
+                // Content before // is already in result, newline will be added on next iteration
+                continue;
+            }
+            result += char;
+            i++;
+        }
+        // Check for unclosed block comment at end of file
+        if (state.inBlockComment) {
+            throw LassTranspileError.at('Unclosed /* comment', ErrorCategory.SCAN, blockCommentStartLine, 1, blockCommentStartOffset);
+        }
+        return result;
+    }
+    /**
+     * Gets the 1-based line number for a character offset (static version).
+     */
+    static getLineNumberStatic(text, offset) {
+        let line = 1;
+        for (let i = 0; i < offset && i < text.length; i++) {
+            if (text[i] === '\n')
+                line++;
+        }
+        return line;
+    }
+}
+//# sourceMappingURL=scanner.js.map