@navecss/core 0.3.0 → 0.5.0

package/dist/chunk-SYNQJNVB.js

@@ -0,0 +1,302 @@
+import { atoms } from './chunk-CUL5PLPI.js';
+import { atomClassMap } from './chunk-GZL2VW7C.js';
+
+// src/directive/diagnostics-format.ts
+function vocabulary(extend) {
+  const extendKeys = new Set(Object.keys(extend));
+  const names = [];
+  for (const [name, definition] of Object.entries(atoms)) {
+    if (definition && !extendKeys.has(name)) names.push(name);
+  }
+  for (const [name, definition] of Object.entries(extend)) {
+    if (definition) names.push(name);
+  }
+  return names;
+}
+function distance(a, b) {
+  const d = [];
+  for (let i = 0; i <= a.length; i++) d.push([i]);
+  for (let j = 0; j <= b.length; j++) d[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      let best = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+        best = Math.min(best, d[i - 2][j - 2] + 1);
+      }
+      d[i][j] = best;
+    }
+  }
+  return d[a.length][b.length];
+}
+function normalize(name) {
+  const lower = name.toLowerCase();
+  const withoutPrefix = lower.startsWith("nave-") ? lower.slice(5) : lower;
+  return withoutPrefix.replaceAll("-", "");
+}
+function groupByDistance(normalizedTyped, names) {
+  let minDistance = Infinity;
+  const byDistance = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const d = distance(normalizedTyped, normalize(name));
+    if (!byDistance.has(d)) byDistance.set(d, []);
+    byDistance.get(d).push(name);
+    if (d < minDistance) minDistance = d;
+  }
+  return { byDistance, minDistance };
+}
+function hasCamelCaseNote(typed, candidates, minDistance, extend) {
+  if (minDistance !== 0 || candidates.length !== 1) return false;
+  if (!typed.includes("-")) return false;
+  const candidate = candidates[0];
+  const shadow = extend[candidate];
+  if (shadow) return false;
+  return Object.hasOwn(atomClassMap, candidate);
+}
+function findHint(typed, extend) {
+  const normalizedTyped = normalize(typed);
+  const { byDistance, minDistance } = groupByDistance(normalizedTyped, vocabulary(extend));
+  if (minDistance > 2 || minDistance >= normalizedTyped.length / 2) return void 0;
+  const candidates = byDistance.get(minDistance) ?? [];
+  if (candidates.length === 0) return void 0;
+  return { candidates, camelCaseNote: hasCamelCaseNote(typed, candidates, minDistance, extend) };
+}
+function quoteList(items) {
+  if (items.length === 1) return `"${items[0]}"`;
+  return `${items.slice(0, -1).map((i) => `"${i}"`).join(", ")} or "${items.at(-1)}"`;
+}
+function formatUnknownAtom(name, extend) {
+  const first = `@nave: unknown atom "${name}".`;
+  const hint = findHint(name, extend);
+  if (hint) {
+    const camelCase = hint.camelCaseNote ? ` Atom names are camelCase; "${atomClassMap[hint.candidates[0]]}" is its class.` : "";
+    return `${first} Did you mean ${quoteList(hint.candidates)}?${camelCase}`;
+  }
+  const available = vocabulary(extend).join(", ");
+  return `${first} If it is an atom of your own, pass it in the extend option.
+Available: ${available}`;
+}
+var ANSWERED_BY_STANDALONE = /* @__PURE__ */ new Set([
+  "@navecss/core",
+  "@navecss/core/atomic",
+  "@navecss/core/layers",
+  "@navecss/core/reset",
+  "@navecss/core/standalone",
+  "@navecss/tokens/css"
+]);
+var STANDALONE_PATH = "node_modules/@navecss/core/dist/standalone.css";
+var STANDALONE_CDN_URL = "https://cdn.jsdelivr.net/npm/@navecss/core@<version>/dist/standalone.css";
+var NO_TOKENS_PATH = "node_modules/@navecss/core/dist/no-tokens.css";
+var NO_TOKENS_CDN_URL = "https://cdn.jsdelivr.net/npm/@navecss/core@<version>/dist/no-tokens.css";
+var BAD_PARENT_WORKAROUND = ". A directive here can be written `& { @nave ...; }` inside the group rule instead.";
+function formatBadParent(diagnostic) {
+  const workaround = diagnostic.detail === "nested-group" ? BAD_PARENT_WORKAROUND : "";
+  return `@nave must be the direct child of a CSS rule selector block${workaround}`;
+}
+var FIXED_TEXTS = {
+  "bad-token": (d) => `@nave: unexpected "${d.text ?? ""}"; a directive takes only atom names (separate atom names with spaces)`,
+  "bare-import": (d) => {
+    const specifier = d.text ?? "";
+    const quoted = JSON.stringify(specifier);
+    if (ANSWERED_BY_STANDALONE.has(specifier)) {
+      return `@import ${quoted} names a package, so a browser cannot load it. Link Nave's self-contained stylesheet from the page instead, ahead of your own stylesheets: ${STANDALONE_PATH}, or ${STANDALONE_CDN_URL} with <version> replaced by the version you installed.`;
+    }
+    if (specifier === "@navecss/core/no-tokens") {
+      return `@import ${quoted} names a package, so a browser cannot load it. Link that entry's own file from the page instead, ahead of your own stylesheets: ${NO_TOKENS_PATH}, or ${NO_TOKENS_CDN_URL} with <version> replaced by the version you installed. Not the self-contained stylesheet: it holds Nave's token layer, which this entry leaves out.`;
+    }
+    return `@import ${quoted} names no file relative to the output, so a browser cannot load it. Point it at a file the page can reach, by a path that works from the output or by a URL, or bundle the stylesheet.`;
+  },
+  "has-block": () => "@nave: a directive with a {} block is not supported",
+  "in-keyframes": () => "@nave cannot be used inside @keyframes",
+  "missing-declarations": (d) => `@nave: atom "${d.name ?? ""}" is registered without a declarations object`,
+  "no-atom": () => "@nave: directive names no atom"
+};
+function formatDiagnostic(diagnostic, options = {}) {
+  if (diagnostic.code === "unknown-atom")
+    return formatUnknownAtom(diagnostic.name, options.extend ?? {});
+  if (diagnostic.code === "bad-parent") return formatBadParent(diagnostic);
+  return FIXED_TEXTS[diagnostic.code](diagnostic);
+}
+
+// src/directive/source-map.ts
+var BASE64_DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var NEWLINE_CHARS = /* @__PURE__ */ new Set(["\n", "\r", "\f"]);
+function encodeVLQ(n) {
+  let value = n < 0 ? (-n << 1) + 1 : n << 1;
+  let result = "";
+  do {
+    let digit = value & 31;
+    value >>>= 5;
+    if (value > 0) digit |= 32;
+    result += BASE64_DIGITS[digit];
+  } while (value > 0);
+  return result;
+}
+var BASE64_VALUE = new Map([...BASE64_DIGITS].map((c, i) => [c, i]));
+function decodeVLQSegment(mappings, start) {
+  let value = 0;
+  let shift = 0;
+  let i = start;
+  for (; ; ) {
+    const digit = BASE64_VALUE.get(mappings[i]);
+    i++;
+    value += (digit & 31) << shift;
+    if ((digit & 32) === 0) break;
+    shift += 5;
+  }
+  const isNegative = (value & 1) === 1;
+  const magnitude = value >>> 1;
+  return { value: isNegative ? -magnitude : magnitude, next: i };
+}
+var MappingsBuilder = class {
+  hasSegmentOnLine = false;
+  lines = [[]];
+  outputColumn = 0;
+  outputLine = 0;
+  // A lone trailing `\r`, possibly half of a CRLF pair split across two
+  // `advance()` calls by a removed directive: consumed by the next call's
+  // leading `\n`, if any, instead of double-counted.
+  pendingCR = false;
+  prevGeneratedColumn = 0;
+  prevSourceColumn = 0;
+  prevSourceIndex = 0;
+  prevSourceLine = 0;
+  /**
+   * A plain indexed loop, not `for...of` (which iterates by code point, so
+   * a surrogate pair would advance the column by one instead of two — every
+   * position here is in UTF-16 code units). A line break is CR, FF, LF or a
+   * CRLF pair, CSS Syntax 3's own "newline" (§4.2).
+   */
+  advance(text) {
+    let i = this.consumePendingCR(text);
+    while (i < text.length) {
+      const c = text[i];
+      if (c !== void 0 && NEWLINE_CHARS.has(c)) {
+        i = this.advancePastNewline(text, i, c);
+        continue;
+      }
+      this.outputColumn++;
+      i++;
+    }
+  }
+  /**
+   * `i` past the line break `c` (at `i`): past the whole pair for a `\r`
+   * immediately followed by `\n`, and `pendingCR` set instead when `\r` is
+   * the last character `text` has to offer.
+   */
+  advancePastNewline(text, i, c) {
+    let next = i + 1;
+    if (c === "\r" && text[next] === "\n") {
+      next++;
+    } else if (c === "\r" && next === text.length) {
+      this.pendingCR = true;
+    }
+    this.outputLine++;
+    this.outputColumn = 0;
+    this.lines.push([]);
+    this.prevGeneratedColumn = 0;
+    this.hasSegmentOnLine = false;
+    return next;
+  }
+  /**
+   * How far into `text` `advance` should start: `1` for a lone `\n` that is
+   * really the other half of a CRLF pair split across two calls; `0`
+   * otherwise.
+   */
+  consumePendingCR(text) {
+    if (text.length === 0) return 0;
+    const skip = this.pendingCR && text.startsWith("\n") ? 1 : 0;
+    this.pendingCR = false;
+    return skip;
+  }
+  mark(position) {
+    const sourceIndex = position.sourceIndex ?? 0;
+    const sourceLine = position.line - 1;
+    const generatedColumnDelta = this.hasSegmentOnLine ? this.outputColumn - this.prevGeneratedColumn : this.outputColumn;
+    const sourceIndexDelta = sourceIndex - this.prevSourceIndex;
+    const sourceLineDelta = sourceLine - this.prevSourceLine;
+    const sourceColumnDelta = position.column - this.prevSourceColumn;
+    this.lines[this.outputLine].push(
+      encodeVLQ(generatedColumnDelta) + encodeVLQ(sourceIndexDelta) + encodeVLQ(sourceLineDelta) + encodeVLQ(sourceColumnDelta)
+    );
+    this.prevGeneratedColumn = this.outputColumn;
+    this.prevSourceIndex = sourceIndex;
+    this.prevSourceLine = sourceLine;
+    this.prevSourceColumn = position.column;
+    this.hasSegmentOnLine = true;
+  }
+  toMappings() {
+    return this.lines.map((segments) => segments.join(",")).join(";");
+  }
+};
+function findCandidate(segments, position) {
+  const generatedLine = position.line - 1;
+  let low = 0;
+  let high = segments.length - 1;
+  let candidate;
+  while (low <= high) {
+    const mid = low + high >> 1;
+    const segment = segments[mid];
+    const isAtOrBefore = segment.generatedLine < generatedLine || segment.generatedLine === generatedLine && segment.generatedColumn <= position.column;
+    if (isAtOrBefore) {
+      candidate = segment;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return candidate?.generatedLine === generatedLine ? candidate : void 0;
+}
+function decodeIncomingMap(map) {
+  const sources = map.sources;
+  const segments = decodeSegments(map.mappings);
+  return {
+    sources,
+    sourceRoot: map.sourceRoot,
+    sourcesContent: map.sourcesContent,
+    originalPositionFor(position) {
+      const candidate = findCandidate(segments, position);
+      if (!candidate) return;
+      return {
+        source: sources[candidate.sourceIndex],
+        sourceIndex: candidate.sourceIndex,
+        line: candidate.sourceLine + 1,
+        column: candidate.sourceColumn
+      };
+    }
+  };
+}
+function decodeOneSegment(state, raw, generatedLine) {
+  const col = decodeVLQSegment(raw, 0);
+  state.generatedColumn += col.value;
+  if (col.next >= raw.length) return void 0;
+  const srcIdx = decodeVLQSegment(raw, col.next);
+  state.sourceIndex += srcIdx.value;
+  const srcLine = decodeVLQSegment(raw, srcIdx.next);
+  state.sourceLine += srcLine.value;
+  const srcCol = decodeVLQSegment(raw, srcLine.next);
+  state.sourceColumn += srcCol.value;
+  return {
+    generatedLine,
+    generatedColumn: state.generatedColumn,
+    sourceIndex: state.sourceIndex,
+    sourceLine: state.sourceLine,
+    sourceColumn: state.sourceColumn
+  };
+}
+function decodeSegments(mappings) {
+  const segments = [];
+  const state = { generatedColumn: 0, sourceIndex: 0, sourceLine: 0, sourceColumn: 0 };
+  const lines = mappings.split(";");
+  for (const [generatedLine, line] of lines.entries()) {
+    state.generatedColumn = 0;
+    if (line === "") continue;
+    for (const raw of line.split(",")) {
+      const segment = decodeOneSegment(state, raw, generatedLine);
+      if (segment) segments.push(segment);
+    }
+  }
+  return segments;
+}
+
+export { MappingsBuilder, decodeIncomingMap, formatDiagnostic };

package/dist/chunk-UVHGEVMV.js

@@ -0,0 +1,204 @@
+// src/directive/expand-text-diagnostics.ts
+function lineStartOffsets(text) {
+  const starts = [0];
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (c === "\r") {
+      i++;
+      if (text[i] === "\n") i++;
+      starts.push(i);
+      continue;
+    }
+    if (c === "\n" || c === "\f") {
+      i++;
+      starts.push(i);
+      continue;
+    }
+    i++;
+  }
+  return starts;
+}
+function lastAtOrBefore(starts, offset) {
+  let low = 0;
+  let high = starts.length - 1;
+  while (low < high) {
+    const mid = low + high + 1 >> 1;
+    if (starts[mid] <= offset) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+function createPositionFinder(text) {
+  const starts = lineStartOffsets(text);
+  return (offset) => {
+    const line = lastAtOrBefore(starts, offset);
+    return { line: line + 1, column: offset - starts[line] };
+  };
+}
+function reportDiagnostics(diagnostics, css, options) {
+  const onUnknown = options.onUnknown ?? "error";
+  if (onUnknown === "ignore") return [];
+  const severity = onUnknown === "warn" ? "warning" : "error";
+  const positionAt = createPositionFinder(css);
+  return diagnostics.map((diagnostic) => {
+    const position = positionAt(diagnostic.offset);
+    return {
+      ...diagnostic,
+      severity,
+      ...options.from !== void 0 && { file: options.from },
+      line: position.line,
+      column: position.column + 1
+    };
+  });
+}
+function positionWarnings(warnings, css, file) {
+  const positionAt = createPositionFinder(css);
+  return warnings.toSorted((a, b) => a.offset - b.offset).map(({ offset, text }) => {
+    const position = positionAt(offset);
+    return {
+      text,
+      offset,
+      line: position.line,
+      column: position.column + 1,
+      ...file !== void 0 && { file }
+    };
+  });
+}
+
+// src/directive/bracket-match.ts
+var OPENERS = /* @__PURE__ */ new Set(["(-token", "[-token", "function-token", "{-token"]);
+var CLOSERS = /* @__PURE__ */ new Set([")-token", "]-token", "}-token"]);
+function isMirrorCloser(openerType, closerType) {
+  if (closerType === ")-token") return openerType === "(-token" || openerType === "function-token";
+  if (closerType === "]-token") return openerType === "[-token";
+  return openerType === "{-token";
+}
+function matchBrackets(tokens) {
+  const closerFor = new Int32Array(tokens.length).fill(-1);
+  const opens = [];
+  for (const [i, token] of tokens.entries()) {
+    const { type } = token;
+    if (OPENERS.has(type)) {
+      opens.push(i);
+      continue;
+    }
+    if (!CLOSERS.has(type)) continue;
+    const openIndex = opens.at(-1);
+    if (openIndex === void 0 || !isMirrorCloser(tokens[openIndex].type, type)) continue;
+    opens.pop();
+    closerFor[openIndex] = i;
+  }
+  return closerFor;
+}
+function matchedCloseWithin(closerFor, openIndex, limit) {
+  const closeIndex = closerFor[openIndex];
+  return closeIndex !== -1 && closeIndex < limit ? closeIndex : void 0;
+}
+
+// src/directive/block-reader.ts
+function scanItem(tokens, start, limit, closerFor) {
+  let i = start;
+  while (i < limit) {
+    const type = tokens[i].type;
+    if (OPENERS.has(type)) {
+      const closeIndex = matchedCloseWithin(closerFor, i, limit);
+      if (type === "{-token") {
+        return {
+          end: closeIndex === void 0 ? limit : closeIndex + 1,
+          consumedSemicolon: false,
+          trailingBlock: { openIndex: i, closeIndex }
+        };
+      }
+      i = closeIndex === void 0 ? limit : closeIndex + 1;
+      continue;
+    }
+    if (CLOSERS.has(type)) {
+      if (i === start) return { end: i + 1, consumedSemicolon: false };
+      i++;
+      continue;
+    }
+    if (type === "semicolon-token") return { end: i + 1, consumedSemicolon: true };
+    i++;
+  }
+  return { end: i, consumedSemicolon: false };
+}
+function scanCustomPropertyValue(tokens, start, limit, closerFor) {
+  let i = start;
+  while (i < limit) {
+    const type = tokens[i].type;
+    if (OPENERS.has(type)) {
+      const closeIndex = matchedCloseWithin(closerFor, i, limit);
+      i = closeIndex === void 0 ? limit : closeIndex + 1;
+      continue;
+    }
+    if (type === "semicolon-token") return i + 1;
+    i++;
+  }
+  return i;
+}
+function isColonSoonAfter(tokens, i, limit) {
+  let j = i;
+  while (j < limit && (tokens[j].type === "whitespace-token" || tokens[j].type === "comment")) j++;
+  return tokens[j]?.type === "colon-token";
+}
+function isCustomPropertyName(token) {
+  return token.type === "ident-token" && (token.structured?.value).startsWith("--");
+}
+function atKeywordName(token) {
+  return (token.structured?.value).toLowerCase();
+}
+function toDeclarationItem(start, end) {
+  return { kind: "declaration", start, end };
+}
+function preludeEndOffset(tokens, start, scan, preludeStart) {
+  if (scan.trailingBlock) return tokens[scan.trailingBlock.openIndex].startIndex;
+  const lastContentIndex = scan.consumedSemicolon ? scan.end - 2 : scan.end - 1;
+  return lastContentIndex >= start ? tokens[lastContentIndex].endIndex : preludeStart;
+}
+function toAtRuleItem(tokens, start, scan) {
+  const nameToken = tokens[start];
+  const preludeStart = tokens[start + 1]?.startIndex ?? nameToken.endIndex;
+  return {
+    kind: "at-rule",
+    start,
+    end: scan.end,
+    atKeyword: atKeywordName(nameToken),
+    preludeOffset: preludeStart,
+    preludeEndOffset: preludeEndOffset(tokens, start + 1, scan, preludeStart),
+    ...scan.trailingBlock && {
+      blockStart: scan.trailingBlock.openIndex + 1,
+      blockEnd: scan.trailingBlock.closeIndex ?? scan.end
+    }
+  };
+}
+function toRuleOrInvalidItem(start, scan) {
+  if (!scan.trailingBlock) return { kind: "invalid", start, end: scan.end };
+  return {
+    kind: "rule",
+    start,
+    end: scan.end,
+    blockStart: scan.trailingBlock.openIndex + 1,
+    blockEnd: scan.trailingBlock.closeIndex ?? scan.end
+  };
+}
+function readItem(tokens, start, limit, closerFor) {
+  const first = tokens[start];
+  if (first.type === "at-keyword-token") {
+    return toAtRuleItem(tokens, start, scanItem(tokens, start + 1, limit, closerFor));
+  }
+  if (first.type === "ident-token" && isColonSoonAfter(tokens, start + 1, limit)) {
+    if (isCustomPropertyName(first)) {
+      return toDeclarationItem(start, scanCustomPropertyValue(tokens, start + 1, limit, closerFor));
+    }
+    const scan = scanItem(tokens, start + 1, limit, closerFor);
+    if (!scan.trailingBlock) return toDeclarationItem(start, scan.end);
+    return toRuleOrInvalidItem(start, scan);
+  }
+  return toRuleOrInvalidItem(start, scanItem(tokens, start, limit, closerFor));
+}
+function isNaveAtKeyword(token) {
+  return token.type === "at-keyword-token" && atKeywordName(token) === "nave";
+}
+
+export { OPENERS, atKeywordName, createPositionFinder, isNaveAtKeyword, matchBrackets, positionWarnings, readItem, reportDiagnostics };

package/dist/{chunk-UANF3FGO.js → chunk-ZNTNLGEC.js}

@@ -1,4 +1,5 @@
-import { createPositionFinder, tokenize, matchBrackets, readItem, isNaveAtKeyword } from './chunk-NFS2REPQ.js';
+import { createPositionFinder, matchBrackets, readItem, isNaveAtKeyword } from './chunk-UVHGEVMV.js';
+import { tokenize } from './chunk-2K5EBBF2.js';
 
 // src/directive/find-survivors.ts
 var NATURAL_STOP_CHARS = /* @__PURE__ */ new Set(["\n", ";", "}"]);