mikuru 1.0.24 → 1.0.26

package/CHANGELOG.md

@@ -1,11 +1,21 @@
 # Changelog
 
-## 1.0.24 - 2026-05-14
+## 1.0.26 - 2026-05-15
+
+- Improved scoped CSS rewriting with native CSS nesting, `@starting-style`, additional raw descriptor at-rules, and stronger `:deep(...)` / `:global(...)` parsing around attributes and functional pseudo-class arguments.
+- Added scoped CSS malformed-block diagnostics with offset, line, column, and one-line code frames, including nested CSS block locations and debug `compiler:warning` style payloads.
+- Expanded the dogfood Debug Panel with compiler/style diagnostic message, phase, location, code frame details, event search coverage, and snapshot/copy coverage for diagnostic fields.
+- Added fixture-style scoped CSS compiler coverage and package usage smoke checks for public `compileStyle()` exports, scoped rewriting, and malformed diagnostic fields.
+
+## 1.0.25 - 2026-05-15
 
 - Added Mikuru-native `m-*` directive syntax across DOM rendering, SSR, and hydration while keeping `v-*` as compatibility aliases.
 - Added debug compiler warnings for `v-*` compatibility aliases, pointing users to the matching `m-*` directive spelling.
 - Updated README, docs, examples, and templates to present `m-*` as the recommended directive syntax.
 - Added shared Debug Inspector diagnostic payloads for compiler, runtime, router, SSR, and hydration warning/error events.
+- Expanded the dogfood Debug Panel with a searchable and collapsible component tree, component root reveal, event filters/search, event-to-component navigation, and copyable compact debug snapshots.
+- Split dogfood Debug Panel filtering, tree, formatting, and snapshot logic into tested example helpers while documenting that they are not public package exports.
+- Improved scoped CSS rewriting coverage for complex selectors, nested at-rules, comments, strings, and malformed CSS diagnostics.
 - Added support for `<template m-if>` / `<template m-else-if>` / `<template m-else>` fragment branches across DOM rendering, SSR, and hydration.
 - Added support for keyed `<template m-for>` fragment rows across DOM rendering, SSR, and hydration.
 - Expanded `<template m-for>` coverage for unkeyed fragments, nested fragment loops, and nested `m-if` / `m-else` branches.

package/README.md

@@ -135,21 +135,22 @@ declare const Greeting: MikuruComponent<GreetingProps>;
 - DOM events with `@click`, `m-on:click`, inline handlers, object-form option modifiers, `.prevent`, `.stop`, `.self`, `.once`, `.capture`, `.passive`, key, mouse button, system, and `.exact` modifiers
 - Component events with `@select` and `.once`
 - Attribute bindings with normalized `:class` and `:style`, boolean/form property sync, direct/object `m-bind` modifiers like `.prop`, `.attr`, and `.camel`, plus dynamic arguments like `:[name]` and `@[event]`
-- `m-if`, `m-else-if`, `m-else`, `m-show`, `m-for`, `m-html`, `m-text`, `m-pre`, and `m-cloak`
+- `m-if`, `m-else-if`, `m-else`, `m-show`, `m-for`, `m-html`, `m-text`, `m-pre`, `m-cloak`, `m-once`, and `m-memo`
 - `m-model` for common form controls, checkbox arrays, radio groups, multiple selects, modifiers, and named child component models
 - `v-*` directive spellings remain available as compatibility aliases for existing components and Vue-oriented migrations
-- Component props, events, DOM attribute fallthrough, `useAttrs`, template refs, `defineProps`, `defineEmits`, default slots, named/dynamic slots, and slot props with simple defaults
+- Component props, events, DOM attribute fallthrough, `useAttrs`, template refs, dynamic `<component :is>`, `defineProps`, `defineEmits`, default slots, named/dynamic slots, and slot props with simple defaults
 - CSS class transitions with built-in `<Transition name="fade">`, `m-if` chains, dynamic components, class overrides, `appear`, `mode="out-in"`, and `<TransitionGroup>` for keyed lists
 - Built-in `<Teleport to="#target">` for rendering content outside the current DOM position
 - Built-in `<AsyncBoundary :loading :fallback :delay :timeout>` for grouped async loading, delayed loading UI, boundary timeouts, and retryable async failures with aggregated fallback errors
 - Built-in `<ErrorBoundary :fallback>` for local component mount, descendant event handler, lifecycle, and cleanup fallbacks, with `errorInfo`, `retry`, `reset`, and `:reset-key` recovery
+- Built-in `<KeepAlive>` for caching one dynamic child component with `include`, `exclude`, and `max` controls
 - Runtime helpers including `ref`, `isRef`, `unref`, `toRef`, `toRefs`, `reactive`, `readonly`, lazy cached read-only and writable `computed`, `effect` with optional scheduling, `queueJob`/`flushJobs`, `watch`, `watchEffect` with cleanup callbacks, `nextTick`, lifecycle callbacks including KeepAlive activation hooks, `provide`, `inject`, and `defineAsyncComponent` with ErrorBoundary handoff and SSR loader resolution
 - Routing through `mikuru/router` with route matching, history/hash/memory histories, guards, router context helpers, and `RouterView` / `RouterLink` across mount, SSR, and hydration
 - SSR through `compileSsr()` and `mikuru/server`, covering escaped text, static and bound attributes, content directives, `m-pre`, `m-cloak`, `m-if` chains, `m-for`, async child components, props, named/default slots, scoped slot props, component tree context, Teleport collection, string and async iterable stream rendering, and router route rendering with context propagation
 - Hydration through `compileHydration()` and `hydrateRoute()`, reusing existing SSR DOM while attaching events, syncing text/attributes, recovering structural mismatches with an opt-out remount fallback, hydrating component context/lifecycle hooks, `m-show`, DOM and component `m-model`, `m-pre`, `m-cloak`, initial `m-if` / `m-for` DOM, Teleport target and disabled inline content, delegating child and route components to `hydrate()` when available, and optionally starting router history listening after route hydration
-- Style injection and basic `<style scoped>` selector rewriting
+- Style injection and `<style scoped>` selector rewriting for common selectors, native CSS nesting, `:global(...)`, `:deep(...)`, nested at-rules, and malformed CSS diagnostics
 - Compile errors with filenames, line/column information, code frames, and typo suggestions for built-in attributes, directives, and modifiers
-- Debug diagnostics with optional generated `sourceURL`, `v-*` compatibility warnings, unstable devtools metadata/events, and hydration warnings that include phase, component, and filename context
+- Debug diagnostics with optional generated `sourceURL`, `v-*` compatibility warnings, unstable devtools metadata/events, compiler/style diagnostic locations and frames, and hydration warnings that include phase, component, and filename context
 
 ## Package Exports
 
@@ -180,12 +181,14 @@ import "mikuru/env";
 Compiler, runtime, and server entries are public for lower-level integrations:
 
 ```ts
-import { compile, compileHydration, compileSsr } from "mikuru/compiler";
+import { compile, compileHydration, compileSsr, compileStyle } from "mikuru/compiler";
 import { effect, isRef, nextTick, reactive, readonly, ref, toRef, toRefs, unref, unwrap, watch } from "mikuru/runtime";
 import { hydrateRoute, renderComponentToString, renderRouteToString, renderToStream, renderToString } from "mikuru/server";
 import type { MikuruAsyncBoundaryFallbackProps, MikuruErrorBoundaryFallbackProps, MikuruErrorInfo, MikuruErrorPhase } from "mikuru/runtime";
 ```
 
+`compileStyle()` returns scoped CSS code plus non-throwing diagnostics. Malformed scoped CSS diagnostics include `offset`, `line`, `column`, and a one-line `frame`, and debug builds emit the same fields in `compiler:warning` style diagnostic events.
+
 The package also provides the `mikuru` binary:
 
 ```sh
@@ -227,7 +230,7 @@ const open = ref(false);
 
 Mikuru does not claim Vue compatibility. The v1 package does not include stable devtools or full template type checking.
 
-Scoped CSS is a basic selector rewrite, not a full CSS compiler. Avoid relying on `:global()`, deep selectors, complex nesting, CSS Modules, or preprocessors in v1.
+Scoped CSS is supported for common selector rewriting, native CSS nesting, `:global(...)`, `:deep(...)`, nested at-rules such as `@media`, `@scope`, and `@starting-style`, and malformed block diagnostics. What is not included in v1 is a full CSS compiler: CSS Modules, preprocessors, and project-level CSS transforms stay outside the package.
 
 ## Repository Development
 

package/dist/compiler/compile.js

@@ -1,5 +1,6 @@
 import { analyzeTemplate } from "./analyzeTemplate.js";
 import { emitCompatDirectiveDiagnostics } from "./compatDiagnostics.js";
+import { compileDescriptorStyle } from "./css.js";
 import { generate } from "./generate.js";
 import { parseSfc } from "./parseSfc.js";
 import { parseTemplate } from "./parseTemplate.js";
@@ -14,6 +15,19 @@ export function compile(source, options = {}) {
             offset: descriptor.templateOffset
         });
         emitCompatDirectiveDiagnostics(ast, { debug: options.debug === true, filename: options.filename, phase: "compile" });
+        if (options.debug === true && descriptor.style?.trim()) {
+            const styleResult = compileDescriptorStyle(descriptor, descriptor.styleScoped ? `data-mikuru-scope-preview` : undefined);
+            for (const diagnostic of styleResult.diagnostics) {
+                emitDebugDiagnostic("compiler", diagnostic.level, diagnostic.message, {
+                    phase: "style",
+                    filename: options.filename,
+                    offset: diagnostic.offset,
+                    line: diagnostic.line,
+                    column: diagnostic.column,
+                    frame: diagnostic.frame
+                });
+            }
+        }
         const bindings = analyzeTemplate(ast, { source, filename: options.filename });
         const code = generate(descriptor, ast, { debug: options.debug === true, batchedUpdates: options.batchedUpdates === true });
         const map = createSourceMap(code, descriptor, ast);

package/dist/compiler/compile.js.map

@@ -1 +1 @@
-{"version":3,"file":"compile.js","sourceRoot":"","sources":["../../src/compiler/compile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,UAAU,OAAO,CAAC,MAAc,EAAE,UAA0B,EAAE;IAClE,IAAI,CAAC;QACH,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtD,MAAM,GAAG,GAAG,aAAa,CAAC,UAAU,CAAC,QAAQ,EAAE;YAC7C,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,MAAM;YACN,MAAM,EAAE,UAAU,CAAC,cAAc;SAClC,CAAC,CAAC;QACH,8BAA8B,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;QACrH,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC9E,MAAM,IAAI,GAAG,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,cAAc,KAAK,IAAI,EAAE,CAAC,CAAC;QAC3H,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;QAEnD,OAAO;YACL,IAAI;YACJ,GAAG;YACH,UAAU;YACV,GAAG;YACH,QAAQ;SACT,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,mBAAmB,CAAC,UAAU,EAAE,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;YAC/F,KAAK,EAAE,SAAS;YAChB,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,KAAK;SACN,CAAC,CAAC;QACH,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}
+{"version":3,"file":"compile.js","sourceRoot":"","sources":["../../src/compiler/compile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAE7D,MAAM,UAAU,OAAO,CAAC,MAAc,EAAE,UAA0B,EAAE;IAClE,IAAI,CAAC;QACH,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QACtD,MAAM,GAAG,GAAG,aAAa,CAAC,UAAU,CAAC,QAAQ,EAAE;YAC7C,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,MAAM;YACN,MAAM,EAAE,UAAU,CAAC,cAAc;SAClC,CAAC,CAAC;QACH,8BAA8B,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;QACrH,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI,IAAI,UAAU,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;YACvD,MAAM,WAAW,GAAG,sBAAsB,CAAC,UAAU,EAAE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;YACzH,KAAK,MAAM,UAAU,IAAI,WAAW,CAAC,WAAW,EAAE,CAAC;gBACjD,mBAAmB,CAAC,UAAU,EAAE,UAAU,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,EAAE;oBACpE,KAAK,EAAE,OAAO;oBACd,QAAQ,EAAE,OAAO,CAAC,QAAQ;oBAC1B,MAAM,EAAE,UAAU,CAAC,MAAM;oBACzB,IAAI,EAAE,UAAU,CAAC,IAAI;oBACrB,MAAM,EAAE,UAAU,CAAC,MAAM;oBACzB,KAAK,EAAE,UAAU,CAAC,KAAK;iBACxB,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QACD,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC9E,MAAM,IAAI,GAAG,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,KAAK,IAAI,EAAE,cAAc,EAAE,OAAO,CAAC,cAAc,KAAK,IAAI,EAAE,CAAC,CAAC;QAC3H,MAAM,GAAG,GAAG,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC;QAEnD,OAAO;YACL,IAAI;YACJ,GAAG;YACH,UAAU;YACV,GAAG;YACH,QAAQ;SACT,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,mBAAmB,CAAC,UAAU,EAAE,OAAO,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;YAC/F,KAAK,EAAE,SAAS;YAChB,QAAQ,EAAE,OAAO,CAAC,QAAQ;YAC1B,KAAK;SACN,CAAC,CAAC;QACH,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/compiler/css.d.ts

@@ -0,0 +1,22 @@
+import type { SfcDescriptor } from "./types.js";
+export type CssCompileDiagnostic = {
+    level: "warning";
+    message: string;
+    offset?: number;
+    line?: number;
+    column?: number;
+    frame?: string;
+};
+export type CssCompileOptions = {
+    filename?: string;
+    scoped?: boolean;
+    scopeAttr?: string;
+};
+export type CssCompileResult = {
+    code: string;
+    scoped: boolean;
+    scopeAttr?: string;
+    diagnostics: CssCompileDiagnostic[];
+};
+export declare function compileStyle(css: string, options?: CssCompileOptions): CssCompileResult;
+export declare function compileDescriptorStyle(descriptor: SfcDescriptor, scopeAttr?: string): CssCompileResult;

package/dist/compiler/css.js

@@ -0,0 +1,529 @@
+import { createCodeFrame, getSourceLocation } from "./errors.js";
+const nestedRuleAtRules = new Set(["media", "supports", "container", "layer", "scope", "starting-style"]);
+const rawBlockAtRules = new Set([
+    "keyframes",
+    "-webkit-keyframes",
+    "-moz-keyframes",
+    "-o-keyframes",
+    "counter-style",
+    "font-face",
+    "font-feature-values",
+    "page",
+    "property",
+    "viewport"
+]);
+export function compileStyle(css, options = {}) {
+    const diagnostics = [];
+    const trimmed = css.trim();
+    const scoped = options.scoped === true && !!options.scopeAttr;
+    if (!scoped) {
+        return {
+            code: trimmed,
+            scoped: false,
+            diagnostics
+        };
+    }
+    return {
+        code: scopeCss(trimmed, options.scopeAttr, diagnostics, trimmed),
+        scoped: true,
+        scopeAttr: options.scopeAttr,
+        diagnostics
+    };
+}
+export function compileDescriptorStyle(descriptor, scopeAttr) {
+    return compileStyle(descriptor.style ?? "", {
+        filename: descriptor.filename,
+        scoped: descriptor.styleScoped === true,
+        scopeAttr
+    });
+}
+function scopeCss(css, scopeAttr, diagnostics, rootCss, offset = 0) {
+    let result = "";
+    let index = 0;
+    while (index < css.length) {
+        const openIndex = findNextTopLevelChar(css, "{", index);
+        if (openIndex === -1) {
+            result += css.slice(index);
+            break;
+        }
+        const closeIndex = findMatchingBrace(css, openIndex);
+        if (closeIndex === -1) {
+            const unclosedOpenIndex = findUnclosedOpenIndex(css, openIndex, "{", "}");
+            const diagnosticOffset = offset + unclosedOpenIndex;
+            const location = getSourceLocation(rootCss, diagnosticOffset);
+            diagnostics.push({
+                level: "warning",
+                message: "Could not scope a CSS rule because its block is missing a closing brace.",
+                offset: diagnosticOffset,
+                line: location.line,
+                column: location.column,
+                frame: createCodeFrame(rootCss, location)
+            });
+            result += css.slice(index);
+            break;
+        }
+        const preludeStart = findPreludeStart(css, index, openIndex);
+        const beforePrelude = css.slice(index, preludeStart);
+        const prelude = css.slice(preludeStart, openIndex);
+        const body = css.slice(openIndex + 1, closeIndex);
+        const scopedRule = scopeRule(prelude, body, scopeAttr, diagnostics, rootCss, offset + openIndex + 1);
+        result += beforePrelude + scopedRule;
+        index = closeIndex + 1;
+    }
+    return result;
+}
+function scopeRule(prelude, body, scopeAttr, diagnostics, rootCss, bodyOffset) {
+    const trimmedPrelude = prelude.trim();
+    if (!trimmedPrelude) {
+        return `${prelude}{${body}}`;
+    }
+    if (trimmedPrelude.startsWith("@")) {
+        const atRuleName = readAtRuleName(trimmedPrelude);
+        if (nestedRuleAtRules.has(atRuleName)) {
+            return `${prelude}{${scopeCss(body, scopeAttr, diagnostics, rootCss, bodyOffset)}}`;
+        }
+        if (rawBlockAtRules.has(atRuleName)) {
+            return `${prelude}{${body}}`;
+        }
+        return bodyContainsRules(body) ? `${prelude}{${scopeCss(body, scopeAttr, diagnostics, rootCss, bodyOffset)}}` : `${prelude}{${body}}`;
+    }
+    const scopedBody = bodyContainsRules(body) ? scopeCss(body, scopeAttr, diagnostics, rootCss, bodyOffset) : body;
+    return `${scopeSelectorList(prelude, scopeAttr)}{${scopedBody}}`;
+}
+function scopeSelectorList(selectorSource, scopeAttr) {
+    return splitSelectorList(selectorSource)
+        .map((selector) => scopeSingleSelector(selector, scopeAttr))
+        .join(",");
+}
+function scopeSingleSelector(selector, scopeAttr) {
+    const leading = selector.match(/^\s*/)?.[0] ?? "";
+    const trailing = selector.match(/\s*$/)?.[0] ?? "";
+    let body = selector.trim();
+    if (!body || body.includes(`[${scopeAttr}]`)) {
+        return selector;
+    }
+    if (isPureGlobalSelector(selector, "global")) {
+        body = unwrapFunctionalPseudo(body, "global");
+        return `${leading}${body}${trailing}`;
+    }
+    const globalMatch = findFunctionalPseudo(body, "global");
+    if (globalMatch) {
+        const prefix = body.slice(0, globalMatch.start).trimEnd();
+        const argument = globalMatch.argument.trim();
+        const suffix = body.slice(globalMatch.end).trimStart();
+        const scopedPrefix = prefix ? insertScopeAttribute(prefix, scopeAttr) : "";
+        return `${leading}${scopedPrefix}${scopedPrefix ? " " : ""}${argument}${suffix ? ` ${suffix}` : ""}${trailing}`;
+    }
+    const deepMatch = findFunctionalPseudo(body, "deep");
+    if (deepMatch) {
+        const prefix = body.slice(0, deepMatch.start).trimEnd();
+        const argument = deepMatch.argument.trim();
+        const suffix = body.slice(deepMatch.end).trimStart();
+        const scopedPrefix = prefix ? insertScopeAttribute(prefix, scopeAttr) : `[${scopeAttr}]`;
+        return `${leading}${scopedPrefix} ${argument}${suffix ? ` ${suffix}` : ""}${trailing}`;
+    }
+    return `${leading}${insertScopeAttribute(body, scopeAttr)}${trailing}`;
+}
+function insertScopeAttribute(selector, scopeAttr) {
+    const insertIndex = findScopeInsertIndex(selector);
+    if (insertIndex === -1) {
+        return `${selector}[${scopeAttr}]`;
+    }
+    return `${selector.slice(0, insertIndex)}[${scopeAttr}]${selector.slice(insertIndex)}`;
+}
+function findScopeInsertIndex(selector) {
+    let depth = 0;
+    let quote;
+    let lastCombinator = -1;
+    let firstPseudoInTarget = -1;
+    for (let index = 0; index < selector.length; index += 1) {
+        const char = selector[index];
+        const previous = selector[index - 1];
+        if (char === "\\") {
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "(" || char === "[") {
+            depth += 1;
+            continue;
+        }
+        if (char === ")" || char === "]") {
+            depth = Math.max(0, depth - 1);
+            continue;
+        }
+        if (depth > 0) {
+            continue;
+        }
+        if (isCombinator(char)) {
+            lastCombinator = index;
+            firstPseudoInTarget = -1;
+            continue;
+        }
+        if (char === ":" && index > lastCombinator && firstPseudoInTarget === -1) {
+            firstPseudoInTarget = index;
+        }
+    }
+    return firstPseudoInTarget === -1 ? selector.length : firstPseudoInTarget;
+}
+function splitSelectorList(selectorSource) {
+    const selectors = [];
+    let start = 0;
+    let depth = 0;
+    let quote;
+    for (let index = 0; index < selectorSource.length; index += 1) {
+        const char = selectorSource[index];
+        const previous = selectorSource[index - 1];
+        if (char === "\\") {
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "(" || char === "[") {
+            depth += 1;
+            continue;
+        }
+        if (char === ")" || char === "]") {
+            depth = Math.max(0, depth - 1);
+            continue;
+        }
+        if (char === "," && depth === 0) {
+            selectors.push(selectorSource.slice(start, index));
+            start = index + 1;
+        }
+    }
+    selectors.push(selectorSource.slice(start));
+    return selectors;
+}
+function unwrapFunctionalPseudo(selector, name) {
+    const match = findFunctionalPseudo(selector, name);
+    if (!match) {
+        return selector;
+    }
+    return `${selector.slice(0, match.start)}${match.argument}${selector.slice(match.end)}`;
+}
+function isPureGlobalSelector(selector, name) {
+    const match = findFunctionalPseudo(selector.trim(), name);
+    return match?.start === 0 && match.end === selector.trim().length;
+}
+function findFunctionalPseudo(selector, name) {
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let quote;
+    for (let index = 0; index < selector.length; index += 1) {
+        const char = selector[index];
+        const previous = selector[index - 1];
+        if (char === "\\") {
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "[") {
+            bracketDepth += 1;
+            continue;
+        }
+        if (char === "]") {
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            continue;
+        }
+        if (bracketDepth > 0) {
+            continue;
+        }
+        if (char === "(") {
+            parenDepth += 1;
+            continue;
+        }
+        if (char === ")") {
+            parenDepth = Math.max(0, parenDepth - 1);
+            continue;
+        }
+        if (char !== ":" || parenDepth > 0 || !matchesFunctionalPseudoName(selector, index, name)) {
+            continue;
+        }
+        const argumentStart = index + name.length + 2;
+        const close = findMatchingParen(selector, argumentStart - 1);
+        if (close === -1) {
+            return undefined;
+        }
+        return {
+            start: index,
+            end: close + 1,
+            argument: selector.slice(argumentStart, close)
+        };
+    }
+    return undefined;
+}
+function matchesFunctionalPseudoName(selector, colonIndex, name) {
+    if (selector[colonIndex + 1] === ":") {
+        return false;
+    }
+    const nameStart = colonIndex + 1;
+    const nameEnd = nameStart + name.length;
+    return selector.slice(nameStart, nameEnd) === name && selector[nameEnd] === "(";
+}
+function findPreludeStart(css, searchStart, openIndex) {
+    let boundary = searchStart;
+    let quote;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let inComment = false;
+    for (let index = searchStart; index < openIndex; index += 1) {
+        const char = css[index];
+        const next = css[index + 1];
+        const previous = css[index - 1];
+        if (char === "\\") {
+            index += 1;
+            continue;
+        }
+        if (inComment) {
+            if (char === "*" && next === "/") {
+                inComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inComment = true;
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "(") {
+            parenDepth += 1;
+            continue;
+        }
+        if (char === ")") {
+            parenDepth = Math.max(0, parenDepth - 1);
+            continue;
+        }
+        if (char === "[") {
+            bracketDepth += 1;
+            continue;
+        }
+        if (char === "]") {
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            continue;
+        }
+        if ((char === "}" || char === ";") && parenDepth === 0 && bracketDepth === 0) {
+            boundary = index + 1;
+        }
+    }
+    return skipCssIgnorablePrefix(css, boundary, openIndex);
+}
+function skipCssIgnorablePrefix(css, start, end) {
+    let index = start;
+    while (index < end) {
+        while (index < end && /\s/.test(css[index])) {
+            index += 1;
+        }
+        if (css[index] === "/" && css[index + 1] === "*") {
+            const commentEnd = css.indexOf("*/", index + 2);
+            if (commentEnd === -1 || commentEnd + 2 > end) {
+                return start;
+            }
+            index = commentEnd + 2;
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+function findNextTopLevelChar(source, target, start) {
+    let quote;
+    let parenDepth = 0;
+    let bracketDepth = 0;
+    let inComment = false;
+    for (let index = start; index < source.length; index += 1) {
+        const char = source[index];
+        const next = source[index + 1];
+        const previous = source[index - 1];
+        if (char === "\\") {
+            index += 1;
+            continue;
+        }
+        if (inComment) {
+            if (char === "*" && next === "/") {
+                inComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inComment = true;
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === "(") {
+            parenDepth += 1;
+            continue;
+        }
+        if (char === ")") {
+            parenDepth = Math.max(0, parenDepth - 1);
+            continue;
+        }
+        if (char === "[") {
+            bracketDepth += 1;
+            continue;
+        }
+        if (char === "]") {
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            continue;
+        }
+        if (char === target && parenDepth === 0 && bracketDepth === 0) {
+            return index;
+        }
+    }
+    return -1;
+}
+function findMatchingBrace(source, openIndex) {
+    return findMatchingPair(source, openIndex, "{", "}");
+}
+function findMatchingParen(source, openIndex) {
+    return findMatchingPair(source, openIndex, "(", ")");
+}
+function findMatchingPair(source, openIndex, openChar, closeChar) {
+    let depth = 0;
+    let quote;
+    let inComment = false;
+    for (let index = openIndex; index < source.length; index += 1) {
+        const char = source[index];
+        const next = source[index + 1];
+        const previous = source[index - 1];
+        if (char === "\\") {
+            index += 1;
+            continue;
+        }
+        if (inComment) {
+            if (char === "*" && next === "/") {
+                inComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inComment = true;
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === openChar) {
+            depth += 1;
+        }
+        else if (char === closeChar) {
+            depth -= 1;
+            if (depth === 0) {
+                return index;
+            }
+        }
+    }
+    return -1;
+}
+function findUnclosedOpenIndex(source, openIndex, openChar, closeChar) {
+    const openIndexes = [];
+    let quote;
+    let inComment = false;
+    for (let index = openIndex; index < source.length; index += 1) {
+        const char = source[index];
+        const next = source[index + 1];
+        const previous = source[index - 1];
+        if (char === "\\") {
+            index += 1;
+            continue;
+        }
+        if (inComment) {
+            if (char === "*" && next === "/") {
+                inComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inComment = true;
+            index += 1;
+            continue;
+        }
+        if (quote) {
+            if (char === quote && previous !== "\\") {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (char === openChar) {
+            openIndexes.push(index);
+        }
+        else if (char === closeChar) {
+            openIndexes.pop();
+        }
+    }
+    return openIndexes.at(-1) ?? openIndex;
+}
+function readAtRuleName(prelude) {
+    const match = prelude.match(/^@([-\w]+)/);
+    return match?.[1].toLowerCase() ?? "";
+}
+function bodyContainsRules(body) {
+    return findNextTopLevelChar(body, "{", 0) !== -1;
+}
+function isCombinator(char) {
+    return char === ">" || char === "+" || char === "~" || /\s/.test(char);
+}
+//# sourceMappingURL=css.js.map