@navecss/core 0.4.0 → 0.6.0

package/dist/chunk-LADFXRWQ.js

@@ -1,1089 +0,0 @@
-import { reportDiagnostics, tokenize, matchBrackets, createPositionFinder, readItem, isNaveAtKeyword, atKeywordName, OPENERS } from './chunk-NFS2REPQ.js';
-import { decodeIncomingMap, MappingsBuilder } from './chunk-SYNQJNVB.js';
-import { atoms } from './chunk-CUL5PLPI.js';
-
-// src/directive/expand-text-output.ts
-function toOriginal(position, incoming) {
-  if (!incoming) return position;
-  const original = incoming.originalPositionFor(position);
-  return original ? { line: original.line, column: original.column, sourceIndex: original.sourceIndex } : void 0;
-}
-function appendMappedRange(ctx, range, sourceForToken) {
-  const { builder, output, incoming } = ctx;
-  const { text, rangeStart, rangeEnd, tokensInRange } = range;
-  let cursor = rangeStart;
-  for (const token of tokensInRange) {
-    const before = text.slice(cursor, token.startIndex);
-    output.push(before);
-    builder.advance(before);
-    const source = toOriginal(sourceForToken(token), incoming);
-    if (source) builder.mark(source);
-    const body = text.slice(token.startIndex, token.endIndex);
-    output.push(body);
-    builder.advance(body);
-    cursor = token.endIndex;
-  }
-  const rest = text.slice(cursor, rangeEnd);
-  output.push(rest);
-  builder.advance(rest);
-}
-function tokensBetween(tokens, cursor, start, end) {
-  let i = cursor.index;
-  while (i < tokens.length && tokens[i].startIndex < start) i++;
-  const result = [];
-  while (i < tokens.length && tokens[i].startIndex < end) {
-    result.push(tokens[i]);
-    i++;
-  }
-  cursor.index = i;
-  return result;
-}
-function appendGap(ctx, gap) {
-  appendMappedRange(
-    ctx,
-    {
-      text: gap.css,
-      rangeStart: gap.start,
-      rangeEnd: gap.end,
-      tokensInRange: tokensBetween(gap.tokens, ctx.gapTokenCursor, gap.start, gap.end)
-    },
-    (t) => gap.positionAt(t.startIndex)
-  );
-}
-function appendEditParts(ctx, edit) {
-  for (const part of edit.parts) {
-    const partTokens = tokenize(part.text);
-    appendMappedRange(
-      ctx,
-      { text: part.text, rangeStart: 0, rangeEnd: part.text.length, tokensInRange: partTokens },
-      () => part.source
-    );
-  }
-}
-function buildOutput(input) {
-  const incoming = input.inputSourceMap ? decodeIncomingMap(input.inputSourceMap) : void 0;
-  const sorted = [...input.edits].toSorted((a, b) => a.start - b.start || a.end - b.end);
-  const ctx = {
-    builder: new MappingsBuilder(),
-    output: [],
-    incoming,
-    gapTokenCursor: { index: 0 }
-  };
-  let cursor = 0;
-  for (const edit of sorted) {
-    appendGap(ctx, {
-      css: input.css,
-      tokens: input.tokens,
-      start: cursor,
-      end: edit.start,
-      positionAt: input.positionAt
-    });
-    appendEditParts(ctx, edit);
-    cursor = Math.max(cursor, edit.end);
-  }
-  appendGap(ctx, {
-    css: input.css,
-    tokens: input.tokens,
-    start: cursor,
-    end: input.css.length,
-    positionAt: input.positionAt
-  });
-  const sources = incoming ? [...incoming.sources] : [input.from ?? "<input>"];
-  const map = {
-    version: 3,
-    sources,
-    names: [],
-    mappings: ctx.builder.toMappings(),
-    // Kept as authored, not re-derived: the incoming map's own sourceRoot
-    // and sourcesContent describe ITS sources, unrelated to anything this
-    // pass computes, and dropping them silently would strand a devtools
-    // "view source" that only ever worked because they were there.
-    ...incoming?.sourceRoot !== void 0 && { sourceRoot: incoming.sourceRoot },
-    ...incoming?.sourcesContent !== void 0 && { sourcesContent: incoming.sourcesContent }
-  };
-  return { css: ctx.output.join(""), map: JSON.stringify(map) };
-}
-
-// src/directive/group-at-rules.ts
-var WORKAROUND_GROUP_AT_RULE_NAMES = /* @__PURE__ */ new Set([
-  "container",
-  "layer",
-  "media",
-  "scope",
-  "starting-style",
-  "supports"
-]);
-
-// src/directive/expand-text-context.ts
-function isKeyframesName(name) {
-  return /keyframes$/i.test(name);
-}
-function childContext(tokens, item, context) {
-  const { isInsideKeyframes, hasStyleRuleAncestor } = context;
-  if (item.kind === "rule") {
-    return {
-      isStyleRuleParent: true,
-      isInsideKeyframes,
-      hasStyleRuleAncestor: true,
-      isWorkaroundGroup: false
-    };
-  }
-  const name = atKeywordName(tokens[item.start]);
-  const isKeyframes = isInsideKeyframes || isKeyframesName(name);
-  return {
-    isStyleRuleParent: false,
-    isInsideKeyframes: isKeyframes,
-    hasStyleRuleAncestor,
-    isWorkaroundGroup: WORKAROUND_GROUP_AT_RULE_NAMES.has(name) && !isKeyframes && hasStyleRuleAncestor
-  };
-}
-
-// src/directive/expand-text-eof-close.ts
-function hasUnescapedTrailingChar(raw, char) {
-  if (raw.length < 2 || raw.at(-1) !== char) return false;
-  let backslashes = 0;
-  for (let i = raw.length - 2; i >= 0 && raw[i] === "\\"; i--) backslashes++;
-  return backslashes % 2 === 0;
-}
-function trailingBackslashCount(raw) {
-  let count = 0;
-  for (let i = raw.length - 1; i >= 0 && raw[i] === "\\"; i--) count++;
-  return count;
-}
-function lexicalEofCloser(token) {
-  if (token.type === "string-token") {
-    const quote = token.raw[0];
-    if (quote === void 0 || hasUnescapedTrailingChar(token.raw, quote)) return void 0;
-    const hasDanglingEscape = trailingBackslashCount(token.raw) % 2 === 1;
-    return hasDanglingEscape ? `\\${quote}` : quote;
-  }
-  if (token.type === "url-token" || token.type === "bad-url-token") {
-    if (token.raw.endsWith(")")) return void 0;
-    return trailingBackslashCount(token.raw) % 2 === 1 ? String.raw`\)` : ")";
-  }
-  return void 0;
-}
-function bracketEofCloser(type) {
-  if (type === "{-token") return "}";
-  if (type === "[-token") return "]";
-  return ")";
-}
-function scanFrameTail(w, start, limit) {
-  const unmatchedOpeners = [];
-  let hasDanglingText = false;
-  let hasOpenColon = false;
-  let i = start;
-  while (i < limit) {
-    const token = w.tokens[i];
-    const type = token.type;
-    if (type !== "whitespace-token" && type !== "comment") hasDanglingText = true;
-    if (type === "semicolon-token") {
-      hasOpenColon = false;
-    } else if (type === "colon-token") {
-      hasOpenColon = true;
-    } else if (OPENERS.has(type)) {
-      const closeIndex = w.closerFor[i];
-      if (closeIndex === -1 || closeIndex >= limit) {
-        unmatchedOpeners.push(i);
-      } else {
-        i = closeIndex;
-      }
-    }
-    i++;
-  }
-  return { unmatchedOpeners: unmatchedOpeners.toReversed(), hasDanglingText, hasOpenColon };
-}
-function eofClosers(w, start, limit, last) {
-  const closers = [];
-  if (last) {
-    const lexical = lexicalEofCloser(last);
-    if (lexical) closers.push(lexical);
-  }
-  const scan = scanFrameTail(w, start, limit);
-  for (const openIndex of scan.unmatchedOpeners) {
-    closers.push(bracketEofCloser(w.tokens[openIndex].type));
-  }
-  if (scan.hasOpenColon) {
-    closers.push(";");
-  } else if (closers.length === 0 && scan.hasDanglingText) {
-    closers.push("{}");
-  }
-  return closers.join("");
-}
-function closeInfoFor(w, frameStart, blockEndIndex, scanLimit) {
-  const closer = w.tokens[blockEndIndex];
-  if (closer) return { position: closer.startIndex, prefix: "" };
-  const last = scanLimit > frameStart ? w.tokens[scanLimit - 1] : void 0;
-  if (last?.type === "comment") {
-    const isClosed = last.raw.length >= 4 && last.raw.endsWith("*/");
-    return { position: isClosed ? w.css.length : last.startIndex, prefix: "" };
-  }
-  return { position: w.css.length, prefix: eofClosers(w, frameStart, scanLimit, last) };
-}
-
-// src/directive/expand-text-render.ts
-function withoutLineTerminators(value) {
-  return value.replaceAll(/\r\n|[\r\n\f]/g, " ");
-}
-function renderDeclarations(decls) {
-  return decls.map((d) => `${d.prop}: ${withoutLineTerminators(d.value)}`).join("; ");
-}
-function renderRule(selector, decls) {
-  return `${selector} { ${renderDeclarations(decls)} }`;
-}
-function renderBlock(block) {
-  if (block.kind === "pseudo") return renderRule(block.selector, block.declarations);
-  const inner = [];
-  if (block.declarations.length > 0) inner.push(renderRule("&", block.declarations));
-  for (const pseudo of block.pseudos) inner.push(renderRule(pseudo.selector, pseudo.declarations));
-  return `@${block.kind} ${block.condition} { ${inner.join(" ")} }`;
-}
-function renderInline(declarations, isWrapped) {
-  if (declarations.length === 0) return "";
-  if (isWrapped) return renderRule("&", declarations);
-  return `${renderDeclarations(declarations)};`;
-}
-
-// src/selector-utils.ts
-function isCommentClose(text, index, commentStart) {
-  return text[index] === "/" && text[index - 1] === "*" && index - 1 >= commentStart + 2;
-}
-function isConsumedAsLiteral(state, text, index) {
-  if (state.commentStart !== void 0) {
-    if (isCommentClose(text, index, state.commentStart)) state.commentStart = void 0;
-    return true;
-  }
-  if (state.isEscaped) {
-    state.isEscaped = false;
-    return true;
-  }
-  if (text[index] === "\\") {
-    state.isEscaped = true;
-    return true;
-  }
-  if (!state.quote) return false;
-  if (text[index] === state.quote) state.quote = void 0;
-  return true;
-}
-function isCodeChar(state, text, index) {
-  if (isConsumedAsLiteral(state, text, index)) return false;
-  const char = text[index];
-  if (char === '"' || char === "'") {
-    state.quote = char;
-    return false;
-  }
-  if (char === "/" && text[index + 1] === "*") {
-    state.commentStart = index;
-    return false;
-  }
-  return true;
-}
-function codeMask(text) {
-  const state = { quote: void 0, isEscaped: false, commentStart: void 0 };
-  return Array.from({ length: text.length }, (_, index) => isCodeChar(state, text, index));
-}
-function splitTopLevel(selectorList) {
-  const mask = codeMask(selectorList);
-  const branches = [];
-  let depth = 0;
-  let start = 0;
-  for (const [index, isCode] of mask.entries()) {
-    if (!isCode) continue;
-    const char = selectorList[index];
-    if (char === "(" || char === "[") depth += 1;
-    else if (char === ")" || char === "]") depth -= 1;
-    else if (char === "," && depth === 0) {
-      branches.push(selectorList.slice(start, index));
-      start = index + 1;
-    }
-  }
-  return [...branches, selectorList.slice(start)];
-}
-function hasNestingSelector(branch) {
-  return codeMask(branch).some((isCode, index) => isCode && branch[index] === "&");
-}
-function anchorSelectorList(selectorList) {
-  return splitTopLevel(selectorList).map((branch) => {
-    const trimmed = branch.trim();
-    if (trimmed === "") {
-      throw new Error(
-        `anchorSelectorList: empty selector branch in pseudo key "${selectorList}". Remove the stray or trailing comma: an empty branch would otherwise compile to a bare "&", matching the atom unconditionally.`
-      );
-    }
-    return hasNestingSelector(trimmed) ? trimmed : `&${trimmed}`;
-  }).join(", ");
-}
-
-// src/directive/prelude-components.ts
-var OPENERS2 = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
-var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
-function findGroupEnd(tokens, start) {
-  let depth = 1;
-  let i = start + 1;
-  while (i < tokens.length && depth > 0) {
-    if (OPENERS2.has(tokens[i].type)) depth++;
-    else if (CLOSERS.has(tokens[i].type)) depth--;
-    i++;
-  }
-  return i;
-}
-function readGroup(tokens, start, prelude) {
-  const end = findGroupEnd(tokens, start);
-  const last = tokens[end - 1] ?? tokens[start];
-  return {
-    kind: "bad-token",
-    text: prelude.slice(tokens[start].startIndex, last.endIndex),
-    offset: tokens[start].startIndex,
-    endOffset: last.endIndex
-  };
-}
-function isBangIdent(tokens, i) {
-  const t = tokens[i];
-  return t.type === "delim-token" && t.structured?.value === "!" && tokens[i + 1]?.type === "ident-token";
-}
-function readBangIdent(tokens, i) {
-  const bang = tokens[i];
-  const ident = tokens[i + 1];
-  return {
-    kind: "bad-token",
-    text: bang.raw + ident.raw,
-    offset: bang.startIndex,
-    endOffset: ident.endIndex
-  };
-}
-function readSingleToken(t) {
-  if (t.type === "ident-token") {
-    return {
-      kind: "ident",
-      name: t.structured?.value,
-      offset: t.startIndex,
-      endOffset: t.endIndex
-    };
-  }
-  return { kind: "bad-token", text: t.raw, offset: t.startIndex, endOffset: t.endIndex };
-}
-function readPreludeComponents(prelude) {
-  const tokens = tokenize(prelude).filter(
-    (t) => t.type !== "whitespace-token" && t.type !== "comment"
-  );
-  const components = [];
-  let i = 0;
-  while (i < tokens.length) {
-    if (OPENERS2.has(tokens[i].type)) {
-      components.push(readGroup(tokens, i, prelude));
-      i = findGroupEnd(tokens, i);
-      continue;
-    }
-    if (isBangIdent(tokens, i)) {
-      components.push(readBangIdent(tokens, i));
-      i += 2;
-      continue;
-    }
-    components.push(readSingleToken(tokens[i]));
-    i++;
-  }
-  return components;
-}
-
-// src/directive/plain-object.ts
-var BOXES = [
-  ["String", String.prototype],
-  ["Number", Number.prototype],
-  ["Boolean", Boolean.prototype],
-  ["BigInt", BigInt.prototype],
-  ["Symbol", Symbol.prototype]
-];
-function boxedPrimitiveKind(value) {
-  if (typeof value !== "object" || value === null) return void 0;
-  for (const [name, prototype] of BOXES) {
-    try {
-      prototype.valueOf.call(value);
-      return name;
-    } catch {
-    }
-  }
-  try {
-    const prototype = Object.getPrototypeOf(value);
-    return BOXES.find(([, box]) => box === prototype)?.[0];
-  } catch {
-    return void 0;
-  }
-}
-function unboxedPrimitive(value) {
-  for (const [, prototype] of BOXES) {
-    try {
-      return prototype.valueOf.call(value);
-    } catch {
-    }
-  }
-  return void 0;
-}
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && boxedPrimitiveKind(value) === void 0;
-}
-
-// src/directive/resolve.ts
-function toDeclarations(decls) {
-  return Object.entries(decls).map(([prop, value]) => ({ prop, value }));
-}
-function isDeclarationsObject(value) {
-  return isPlainObject(value);
-}
-function resolveDeclarations(name, atom) {
-  if (!isDeclarationsObject(atom.declarations)) {
-    throw new Error(`@nave: atom "${name}" is registered without a declarations object`);
-  }
-  return toDeclarations(atom.declarations);
-}
-function resolvePseudoBlocks(pseudos) {
-  if (!pseudos) return [];
-  return Object.entries(pseudos).filter(([, decls]) => decls).map(([selector, decls]) => ({
-    kind: "pseudo",
-    selector,
-    declarations: toDeclarations(decls)
-  }));
-}
-function resolveConditionalBlocks(kind, blocks) {
-  if (!blocks) return [];
-  const result = [];
-  for (const [condition, block] of Object.entries(blocks)) {
-    if (!block) continue;
-    const declarations = block.declarations ? toDeclarations(block.declarations) : [];
-    const pseudos = resolvePseudoBlocks(block.pseudos);
-    if (declarations.length === 0 && pseudos.length === 0) continue;
-    result.push({ kind, condition, declarations, pseudos });
-  }
-  return result;
-}
-function resolveAtom(name, atom) {
-  return {
-    declarations: resolveDeclarations(name, atom),
-    blocks: [
-      ...resolvePseudoBlocks(atom.pseudos),
-      ...resolveConditionalBlocks("media", atom.media),
-      ...resolveConditionalBlocks("container", atom.container)
-    ]
-  };
-}
-function lookupAtom(name, extend) {
-  if (Object.hasOwn(extend, name)) return extend[name] ?? void 0;
-  if (Object.hasOwn(atoms, name)) return atoms[name];
-  return void 0;
-}
-function resolve(names, options = {}) {
-  const extend = options.extend ?? {};
-  const resolved = /* @__PURE__ */ Object.create(null);
-  const unresolved = [];
-  for (const name of names) {
-    const atom = lookupAtom(name, extend);
-    if (!atom) {
-      unresolved.push(name);
-      continue;
-    }
-    resolved[name] = resolveAtom(name, atom);
-  }
-  return { resolved, unresolved };
-}
-
-// src/directive/plan.ts
-function anchorBlock(block) {
-  if (block.kind === "pseudo") {
-    return {
-      kind: "pseudo",
-      selector: anchorSelectorList(block.selector),
-      declarations: block.declarations
-    };
-  }
-  return {
-    kind: block.kind,
-    condition: block.condition,
-    declarations: block.declarations,
-    pseudos: block.pseudos.map((p) => ({ ...p, selector: anchorSelectorList(p.selector) }))
-  };
-}
-function emptyResult(diagnostics) {
-  return { declarations: [], wrapInAmpersand: false, blocks: [], diagnostics };
-}
-function readNames(components) {
-  const names = [];
-  const diagnostics = [];
-  for (const component of components) {
-    if (component.kind === "ident") {
-      names.push(component.name);
-      continue;
-    }
-    diagnostics.push({
-      code: "bad-token",
-      text: component.text,
-      offset: component.offset,
-      endOffset: component.endOffset
-    });
-  }
-  return { names, diagnostics };
-}
-function readUnknownAtomDiagnostics(components, resolved) {
-  const diagnostics = [];
-  for (const component of components) {
-    if (component.kind !== "ident" || Object.hasOwn(resolved, component.name)) continue;
-    diagnostics.push({
-      code: "unknown-atom",
-      name: component.name,
-      offset: component.offset,
-      endOffset: component.endOffset
-    });
-  }
-  return diagnostics;
-}
-function planNames(prelude, options) {
-  const components = readPreludeComponents(prelude);
-  if (components.length === 0) {
-    return emptyResult([{ code: "no-atom", offset: 0, endOffset: prelude.length }]);
-  }
-  const { names, diagnostics } = readNames(components);
-  const { resolved } = resolve(names, { extend: options.extend });
-  diagnostics.push(...readUnknownAtomDiagnostics(components, resolved));
-  diagnostics.sort((a, b) => a.offset - b.offset);
-  const declarations = [];
-  const blocks = [];
-  for (const name of names) {
-    const atom = Object.hasOwn(resolved, name) ? resolved[name] : void 0;
-    if (!atom) continue;
-    declarations.push(...atom.declarations);
-    blocks.push(...atom.blocks.map((block) => anchorBlock(block)));
-  }
-  return { declarations, wrapInAmpersand: false, blocks, diagnostics };
-}
-function plan(prelude, context, options = {}) {
-  if (!context.isStyleRuleParent) {
-    return emptyResult([{ code: "bad-parent", offset: 0, endOffset: prelude.length }]);
-  }
-  if (context.isInsideKeyframes) {
-    return emptyResult([{ code: "in-keyframes", offset: 0, endOffset: prelude.length }]);
-  }
-  const result = planNames(prelude, options);
-  return { ...result, wrapInAmpersand: context.isFollowingNestedNode };
-}
-
-// src/directive/expand-text-walk.ts
-var Walker = class {
-  closerFor;
-  css;
-  diagnostics = [];
-  edits = [];
-  // Built once per call, not once per query: `positionAt` runs once per
-  // output token, and a fresh linear scan on every call made the whole
-  // pass quadratic in the stylesheet's size. Not private: this
-  // project's class-member-order and class-sort lint rules disagree with
-  // each other on where a private field goes relative to the surrounding
-  // public ones, which a field with no access modifier sidesteps.
-  // How far back an EOF-closing frame may look for its own unmatched
-  // brackets/declaration: shrinks to a frame's own start every time that
-  // frame writes its own EOF closers, so an ancestor frame further out
-  // never rediscovers — and re-closes — the same inner construct. Starts
-  // at `tokens.length`, unbounded, since nothing has closed anything yet.
-  eofScanLimit;
-  findPosition;
-  options;
-  tokens;
-  constructor(css, options) {
-    this.css = css;
-    this.tokens = tokenize(css);
-    this.closerFor = matchBrackets(this.tokens);
-    this.options = options;
-    this.findPosition = createPositionFinder(css);
-    this.eofScanLimit = this.tokens.length;
-  }
-  positionAt(offset) {
-    return this.findPosition(offset);
-  }
-};
-function isStructural(token) {
-  return token.type !== "whitespace-token" && token.type !== "comment";
-}
-function skipInert(tokens, i, limit) {
-  let j = i;
-  while (j < limit && !isStructural(tokens[j])) j++;
-  return j;
-}
-function repositionDiagnostics(diagnostics, item, directiveStart, directiveEnd) {
-  const preludeOffset = item.preludeOffset ?? 0;
-  return diagnostics.map((d) => {
-    if (d.code === "unknown-atom" || d.code === "bad-token") {
-      return { ...d, offset: preludeOffset + d.offset, endOffset: preludeOffset + d.endOffset };
-    }
-    return { ...d, offset: directiveStart, endOffset: directiveEnd };
-  });
-}
-function markNestedGroup(diagnostics) {
-  for (const [i, d] of diagnostics.entries()) {
-    if (d.code === "bad-parent") diagnostics[i] = { ...d, detail: "nested-group" };
-  }
-}
-function processDirective(w, site) {
-  const { item, context, hasNestedNode, frame } = site;
-  const directiveStart = w.tokens[item.start].startIndex;
-  const directiveEnd = w.tokens[item.end - 1].endIndex;
-  const source = w.positionAt(directiveStart);
-  const prelude = w.css.slice(item.preludeOffset ?? 0, item.preludeEndOffset ?? 0);
-  const result = plan(
-    prelude,
-    {
-      isStyleRuleParent: context.isStyleRuleParent,
-      isInsideKeyframes: context.isInsideKeyframes,
-      isFollowingNestedNode: hasNestedNode
-    },
-    { extend: w.options.extend }
-  );
-  const positioned = repositionDiagnostics(result.diagnostics, item, directiveStart, directiveEnd);
-  if (context.isWorkaroundGroup) markNestedGroup(positioned);
-  if (item.blockStart !== void 0)
-    positioned.push({ code: "has-block", offset: directiveStart, endOffset: directiveEnd });
-  w.diagnostics.push(...positioned);
-  const inline = renderInline(result.declarations, result.wrapInAmpersand);
-  w.edits.push({
-    start: directiveStart,
-    end: directiveEnd,
-    parts: inline === "" ? [] : [{ text: inline, source }]
-  });
-  for (const block of result.blocks) frame.parts.push({ text: ` ${renderBlock(block)}`, source });
-}
-function isNestedNode(tokens, item) {
-  if (item.kind === "rule") return true;
-  if (item.kind !== "at-rule") return false;
-  return !isNaveAtKeyword(tokens[item.start]);
-}
-function flushFrame(w, frameStart, blockEndIndex, frame) {
-  if (frame.parts.length === 0) return;
-  const close = closeInfoFor(w, frameStart, blockEndIndex, w.eofScanLimit);
-  if (w.tokens[blockEndIndex] === void 0) w.eofScanLimit = frameStart;
-  const parts = close.prefix === "" ? frame.parts : [{ text: close.prefix, source: w.positionAt(close.position) }, ...frame.parts];
-  w.edits.push({ start: close.position, end: close.position, parts });
-}
-function toWalkFrame(w, bounds) {
-  return {
-    i: skipInert(w.tokens, bounds.start, bounds.limit),
-    hasNestedNode: false,
-    limit: bounds.limit,
-    start: bounds.start,
-    context: bounds.context,
-    frame: { parts: [] }
-  };
-}
-function childFrameFor(w, item, context) {
-  if (item.blockStart === void 0 || item.blockEnd === void 0) return void 0;
-  return toWalkFrame(w, {
-    start: item.blockStart,
-    limit: item.blockEnd,
-    context: childContext(w.tokens, item, context)
-  });
-}
-function walkBlock(w, bounds) {
-  const stack = [toWalkFrame(w, bounds)];
-  while (stack.length > 0) {
-    const top = stack.at(-1);
-    if (top.i >= top.limit) {
-      flushFrame(w, top.start, top.limit, top.frame);
-      stack.pop();
-      continue;
-    }
-    const item = readItem(w.tokens, top.i, top.limit, w.closerFor);
-    top.i = skipInert(w.tokens, item.end, top.limit);
-    if (item.kind === "at-rule" && isNaveAtKeyword(w.tokens[item.start])) {
-      processDirective(w, {
-        item,
-        context: top.context,
-        hasNestedNode: top.hasNestedNode,
-        frame: top.frame
-      });
-    } else if (item.kind === "rule" || item.kind === "at-rule") {
-      const child = childFrameFor(w, item, top.context);
-      if (child) stack.push(child);
-    }
-    if (isNestedNode(w.tokens, item)) top.hasNestedNode = true;
-  }
-}
-
-// src/directive/expand-text.ts
-function expandText(css, options = {}) {
-  const w = new Walker(css, options);
-  walkBlock(w, {
-    start: 0,
-    limit: w.tokens.length,
-    context: {
-      isStyleRuleParent: false,
-      isInsideKeyframes: false,
-      hasStyleRuleAncestor: false,
-      isWorkaroundGroup: false
-    }
-  });
-  const { css: outputCss, map } = buildOutput({
-    css: w.css,
-    tokens: w.tokens,
-    edits: w.edits,
-    from: options.from,
-    inputSourceMap: options.inputSourceMap,
-    positionAt: (offset) => w.positionAt(offset)
-  });
-  return { css: outputCss, map, diagnostics: reportDiagnostics(w.diagnostics, css, options) };
-}
-
-// src/snapshot-extend-atoms.ts
-function snapshotDeclarations(declarations) {
-  if (!isPlainObject(declarations)) return declarations;
-  const out = /* @__PURE__ */ Object.create(null);
-  for (const [prop, value] of Object.entries(declarations)) {
-    out[prop] = typeof value === "string" ? value : String(value);
-  }
-  return out;
-}
-function snapshotPseudos(pseudos) {
-  if (!isPlainObject(pseudos)) return pseudos;
-  const out = /* @__PURE__ */ Object.create(null);
-  for (const [selector, declarations] of Object.entries(pseudos)) {
-    out[selector] = snapshotDeclarations(declarations);
-  }
-  return out;
-}
-function snapshotAtBlock(block) {
-  if (!isPlainObject(block)) return block;
-  const out = /* @__PURE__ */ Object.create(null);
-  if ("declarations" in block) out.declarations = snapshotDeclarations(block.declarations);
-  if ("pseudos" in block) out.pseudos = snapshotPseudos(block.pseudos);
-  return out;
-}
-function snapshotAtBlocks(blocks) {
-  if (!isPlainObject(blocks)) return blocks;
-  const out = /* @__PURE__ */ Object.create(null);
-  for (const [condition, block] of Object.entries(blocks)) {
-    out[condition] = snapshotAtBlock(block);
-  }
-  return out;
-}
-function snapshotAtomDefinition(atom) {
-  if (!isPlainObject(atom)) return atom;
-  const out = /* @__PURE__ */ Object.create(null);
-  if ("declarations" in atom) out.declarations = snapshotDeclarations(atom.declarations);
-  if ("pseudos" in atom) out.pseudos = snapshotPseudos(atom.pseudos);
-  if ("media" in atom) out.media = snapshotAtBlocks(atom.media);
-  if ("container" in atom) out.container = snapshotAtBlocks(atom.container);
-  return out;
-}
-function snapshotExtendMap(map) {
-  const out = /* @__PURE__ */ Object.create(null);
-  for (const [name, atom] of Object.entries(map)) {
-    out[name] = snapshotAtomDefinition(atom);
-  }
-  return out;
-}
-
-// src/directive/fold.ts
-function splitAvailable(text) {
-  const lines = text.split("\n");
-  const last = lines.at(-1);
-  if (lines.length > 1 && last?.startsWith("Available: ")) {
-    return { body: lines.slice(0, -1).join("\n"), available: last };
-  }
-  return { body: text, available: void 0 };
-}
-function withoutNavePrefix(text) {
-  return text.startsWith("@nave: ") ? text.slice(7) : text;
-}
-function foldLocated(entries) {
-  const parts = entries.map((entry) => ({ ...splitAvailable(entry.text), entry }));
-  const [first, ...rest] = parts;
-  const lines = [first.body];
-  if (rest.length > 0) {
-    lines.push(`${rest.length} more in this stylesheet:`);
-    for (const { body, entry } of rest) {
-      lines.push(`${entry.line}:${entry.column}: ${withoutNavePrefix(body)}`);
-    }
-  }
-  const available = parts.find((part) => part.available !== void 0)?.available;
-  if (available) lines.push(available);
-  return lines.join("\n");
-}
-
-// src/validate-extend-scan.ts
-function isInert(token) {
-  return token.type === "whitespace-token" || token.type === "comment";
-}
-function isOnlyInert(tokens, from, to) {
-  for (let i = from; i < to; i++) if (!isInert(tokens[i])) return false;
-  return true;
-}
-function hasStrayCurlyCloser(wrapped, from, to) {
-  const matchedClosers = new Set(wrapped.closerFor);
-  for (let i = from; i < to; i++) {
-    if (wrapped.tokens[i].type === "}-token" && !matchedClosers.has(i)) return true;
-  }
-  return false;
-}
-function hasPaddedComment(tokens, from, to) {
-  for (let i = from; i < to; i++) {
-    if (tokens[i].type !== "comment") continue;
-    if (tokens[i - 1]?.type === "whitespace-token" || tokens[i + 1]?.type === "whitespace-token")
-      return true;
-  }
-  return false;
-}
-function hasTopLevelComment(wrapped, from, to) {
-  let i = from;
-  while (i < to) {
-    const closer = wrapped.closerFor[i];
-    const type = wrapped.tokens[i].type;
-    if (closer !== -1 && (type === "(-token" || type === "function-token")) {
-      i = closer + 1;
-      continue;
-    }
-    if (type === "comment") return true;
-    i++;
-  }
-  return false;
-}
-function hasBrokenString(tokens, from, to) {
-  for (let i = from; i < to; i++) {
-    if (tokens[i].type === "bad-string-token" || tokens[i].type === "bad-url-token") return true;
-  }
-  return false;
-}
-function hasUrl(tokens, from, to) {
-  for (let i = from; i < to; i++) {
-    if (tokens[i].type === "url-token" && tokens[i].raw.includes("/*")) return true;
-  }
-  return false;
-}
-function lastNonWhitespace(tokens, from, to) {
-  let i = to - 1;
-  while (i >= from && tokens[i].type === "whitespace-token") i--;
-  return i;
-}
-function hasTopLevelColon(wrapped, from, to) {
-  let i = from;
-  while (i < to) {
-    const closer = wrapped.closerFor[i];
-    const type = wrapped.tokens[i].type;
-    if (closer !== -1 && (type === "(-token" || type === "function-token")) {
-      i = closer + 1;
-      continue;
-    }
-    if (wrapped.tokens[i].type === "colon-token") return true;
-    i++;
-  }
-  return false;
-}
-function hasEscapedCommentOpener(text) {
-  const outsideStrings = tokenize(text).map((token) => token.type === "string-token" ? '""' : token.raw).join("");
-  return outsideStrings.includes(String.raw`\/*`);
-}
-function hasHtmlBreakout(text) {
-  return /<\/?style\b/i.test(text) || text.includes("<!--");
-}
-function hasUnstrippedTrailingSpace(text) {
-  const tokens = tokenize(text);
-  const last = lastNonWhitespace(tokens, 0, tokens.length);
-  const raw = tokens[last]?.raw;
-  return raw !== void 0 && raw !== raw.trimEnd();
-}
-function hasUnstrippedLeadingSpace(text) {
-  const tokens = tokenize(text);
-  const first = tokens.findIndex((token) => token.type !== "whitespace-token");
-  const raw = tokens[first]?.raw;
-  return raw !== void 0 && raw !== raw.trimStart();
-}
-function hasEscapedWhitespace(text) {
-  return /\\[\da-f]{0,6}[\t\n\f\r ]/i.test(text);
-}
-
-// src/validate-extend-breakout.ts
-var SENTINEL = ".nave-sentinel{}";
-var ATOM = "probe";
-function atomFor(splice) {
-  if (splice.kind === "declarations") {
-    return { atoms: { [ATOM]: { declarations: splice.declarations } }, nested: 0 };
-  }
-  const color = { color: "red" };
-  if (splice.kind === "pseudo") {
-    const pseudos = { [splice.key]: color };
-    return { atoms: { [ATOM]: { declarations: {}, pseudos } }, nested: 1 };
-  }
-  const blocks = { [splice.condition]: { declarations: color } };
-  return { atoms: { [ATOM]: { declarations: {}, [splice.atName]: blocks } }, nested: 1 };
-}
-function itemsIn(tokens, closerFor, from, to) {
-  const items = [];
-  let i = from;
-  while (i < to) {
-    const type = tokens[i].type;
-    if (type === "whitespace-token" || type === "comment") {
-      i++;
-      continue;
-    }
-    const item = readItem(tokens, i, to, closerFor);
-    items.push(item);
-    i = Math.max(item.end, i + 1);
-  }
-  return items;
-}
-function textOf(tokens, from, to) {
-  return tokens.slice(from, to).map((token) => token.raw).join("");
-}
-function isExpectedNested(splice, tokens, item) {
-  if (splice.kind === "condition") {
-    return item.kind === "at-rule" && item.atKeyword === splice.atName;
-  }
-  if (item.kind !== "rule" || item.blockStart === void 0) return false;
-  return textOf(tokens, item.start, item.blockStart - 1).trim() === anchorSelectorList(splice.key);
-}
-function readRuleThenSentinel(css) {
-  const tokens = tokenize(css);
-  const closerFor = matchBrackets(tokens);
-  const [rule, sentinel, ...rest] = itemsIn(tokens, closerFor, 0, tokens.length);
-  if (rule === void 0 || sentinel === void 0 || rest.length > 0) return void 0;
-  if (rule.blockStart === void 0 || closerFor[rule.blockStart - 1] !== rule.blockEnd) {
-    return void 0;
-  }
-  const isSentinelWhereAppended = textOf(tokens, 0, sentinel.start).length === css.length - SENTINEL.length;
-  const isSentinelText = textOf(tokens, sentinel.start, sentinel.end) === SENTINEL;
-  const isClosedBeforeIt = isOnlyInert(tokens, rule.end, sentinel.start);
-  return isSentinelWhereAppended && isSentinelText && isClosedBeforeIt ? { closerFor, rule, tokens } : void 0;
-}
-function isInsideRule(splice) {
-  const { atoms: atoms2, nested } = atomFor(splice);
-  let css;
-  try {
-    css = expandText(`.p { @nave ${ATOM}; }
-${SENTINEL}`, {
-      extend: atoms2,
-      onUnknown: "ignore"
-    }).css;
-  } catch {
-    return true;
-  }
-  const read = readRuleThenSentinel(css);
-  if (read === void 0) return false;
-  const { closerFor, rule, tokens } = read;
-  const inner = itemsIn(tokens, closerFor, rule.blockStart, rule.blockEnd);
-  const nestedItems = inner.filter((item) => item.kind === "rule" || item.kind === "at-rule");
-  if (nestedItems.length !== nested) return false;
-  return splice.kind === "declarations" || isExpectedNested(splice, tokens, nestedItems[0]);
-}
-
-// src/validate-extend-walk.ts
-function refuse(describedAs, clause) {
-  throw new Error(
-    `navePlugin({ extend }): ${describedAs} ${clause} extend is trusted, consumer-authored code, not sanitised input \u2014 fix the atom definition.`
-  );
-}
-var ESCAPED_LESS_THAN = String.raw`\3c`;
-function fail(describedAs, reason, value, splice) {
-  if (reason === "rewritten") {
-    refuse(
-      describedAs,
-      `parses, but would not be written back exactly as given: ${JSON.stringify(value)}. A "<" before "style", "/style" or "!--" is written back escaped: write the "<" as ${ESCAPED_LESS_THAN} with a space after it (${ESCAPED_LESS_THAN} /style), or as %3C inside a URL. Whitespace at either end of it is not written back as given: remove it.`
-    );
-  }
-  const clause = "does not parse as a single CSS declaration, selector or condition, ";
-  if (isInsideRule(splice)) {
-    refuse(
-      describedAs,
-      `${clause}though it would stay inside the rule it is spliced into: ${JSON.stringify(value)}. Write exactly one, with nothing else in it: no ";" or second declaration, no comment, and no trailing backslash.`
-    );
-  }
-  refuse(
-    describedAs,
-    `${clause}and would break out of the rule it is spliced into: ${JSON.stringify(value)}.`
-  );
-}
-function kindOf(value) {
-  if (Array.isArray(value)) return "an array";
-  const boxed = boxedPrimitiveKind(value);
-  return boxed === void 0 ? `a ${typeof value}` : `a ${boxed} object`;
-}
-function quoted(value) {
-  if (typeof value === "function" || typeof value === "symbol") return void 0;
-  if (typeof value === "bigint") return `${value}n`;
-  if (typeof value === "number") return String(value);
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return void 0;
-  }
-}
-function printable(value) {
-  const isBoxed = boxedPrimitiveKind(value) !== void 0;
-  return quoted(isBoxed ? unboxedPrimitive(value) : value);
-}
-function failShape(describedAs, value, isAtom) {
-  const printed = printable(value);
-  const shown = printed === void 0 ? "" : `: ${printed}`;
-  const advice = isAtom ? "Write an atom as { declarations: { ... } }." : "Write it as a plain object ({ ... }).";
-  refuse(describedAs, `is ${kindOf(value)}, not a plain object${shown}. ${advice}`);
-}
-function assertShape(value, describedAs) {
-  if (!value || isPlainObject(value)) return;
-  failShape(describedAs, value, false);
-}
-function assertDeclarationsSafe(declarations, where, p) {
-  assertShape(declarations, `${where}'s declarations`);
-  if (!isPlainObject(declarations)) return;
-  for (const [prop, value] of Object.entries(declarations)) {
-    const propRefusal = p.propRefusal(prop);
-    if (propRefusal) {
-      fail(`${where}'s declaration property "${prop}"`, propRefusal, prop, {
-        declarations: { [prop]: "0" },
-        kind: "declarations"
-      });
-    }
-    if (typeof value !== "string") continue;
-    const valueRefusal = p.declarationRefusal(prop, value);
-    if (valueRefusal) {
-      fail(`${where}'s declaration value for "${prop}"`, valueRefusal, value, {
-        declarations: { [prop]: value },
-        kind: "declarations"
-      });
-    }
-  }
-}
-function assertPseudosSafe(pseudos, where, p) {
-  assertShape(pseudos, `${where}'s pseudos`);
-  if (!isPlainObject(pseudos)) return;
-  for (const [pseudo, declarations] of Object.entries(pseudos)) {
-    const refusal = p.selectorRefusal(pseudo);
-    if (refusal) {
-      fail(`${where}'s pseudo "${pseudo}"`, refusal, pseudo, { key: pseudo, kind: "pseudo" });
-    }
-    assertDeclarationsSafe(declarations, `${where}'s pseudo "${pseudo}"`, p);
-  }
-}
-function assertAtBlocksSafe(blocks, atName, where, p) {
-  assertShape(blocks, `${where}'s ${atName} map`);
-  if (!isPlainObject(blocks)) return;
-  for (const [condition, block] of Object.entries(blocks)) {
-    const refusal = p.conditionRefusal(atName, condition);
-    if (refusal) {
-      fail(`${where}'s ${atName} condition "${condition}"`, refusal, condition, {
-        atName,
-        condition,
-        kind: "condition"
-      });
-    }
-    const blockWhere = `${where}'s ${atName} "${condition}"`;
-    assertShape(block, `${blockWhere} block`);
-    if (!isPlainObject(block)) continue;
-    assertDeclarationsSafe(block.declarations, blockWhere, p);
-    assertPseudosSafe(block.pseudos, blockWhere, p);
-  }
-}
-function walkExtendAtoms(extend, predicates) {
-  for (const [name, atom] of Object.entries(extend)) {
-    if (!atom) continue;
-    const where = `atom "${name}"`;
-    if (!isPlainObject(atom)) failShape(where, atom, true);
-    assertDeclarationsSafe(atom.declarations, where, predicates);
-    assertPseudosSafe(atom.pseudos, where, predicates);
-    assertAtBlocksSafe(atom.media, "media", where, predicates);
-    assertAtBlocksSafe(atom.container, "container", where, predicates);
-  }
-}
-
-export { WORKAROUND_GROUP_AT_RULE_NAMES, anchorSelectorList, expandText, foldLocated, hasBrokenString, hasEscapedCommentOpener, hasEscapedWhitespace, hasHtmlBreakout, hasPaddedComment, hasStrayCurlyCloser, hasTopLevelColon, hasTopLevelComment, hasUnstrippedLeadingSpace, hasUnstrippedTrailingSpace, hasUrl, isInert, isOnlyInert, lastNonWhitespace, plan, snapshotExtendMap, walkExtendAtoms };