@navecss/core 0.2.0 → 0.3.0

package/dist/chunk-NKUZNRF4.js

@@ -0,0 +1,42 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import url from 'url';
+
+// src/postcss-extend-module.ts
+function resolveExtendSpecifier(specifier, dir = process.cwd()) {
+  const file = path.resolve(dir, specifier);
+  const stats = fs.existsSync(file) ? fs.statSync(file) : void 0;
+  if (!stats?.isFile()) {
+    throw new Error(`@nave: cannot find extend module "${specifier}" from "${dir}"`);
+  }
+  return file;
+}
+function isJsonPath(file) {
+  return path.extname(file).toLowerCase() === ".json";
+}
+async function importExtendMap(moduleUrl, file) {
+  const value = isJsonPath(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : (await import(moduleUrl)).default;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `@nave: extend module "${file}" must have a default export that is a plain object`
+    );
+  }
+  return value;
+}
+function loadExtendModule(file, cache) {
+  const digest = crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+  const moduleUrl = `${url.pathToFileURL(file).href}?v=${digest}`;
+  const cached = cache.get(moduleUrl);
+  if (cached) return cached;
+  const filePrefix = `${url.pathToFileURL(file).href}?v=`;
+  for (const key of cache.keys()) if (key.startsWith(filePrefix)) cache.delete(key);
+  const pending = importExtendMap(moduleUrl, file);
+  cache.set(moduleUrl, pending);
+  return pending;
+}
+async function applyExtendModule(file, cache, setExtend) {
+  setExtend(await loadExtendModule(file, cache));
+}
+
+export { applyExtendModule, resolveExtendSpecifier };

package/dist/chunk-R6JJZGXC.js

@@ -0,0 +1,94 @@
+import { walkExtendAtoms, hasEscapedCommentOpener, isOnlyInert, hasTopLevelComment, hasUnstrippedTrailingSpace, hasUnstrippedLeadingSpace, lastNonWhitespace, isInert, hasPaddedComment, hasBrokenString, hasUrl, hasStrayCurlyCloser, anchorSelectorList, hasEscapedWhitespace, hasHtmlBreakout, hasTopLevelColon } from './chunk-S7DZUVV3.js';
+import { tokenize, matchBrackets, readItem } from './chunk-NFS2REPQ.js';
+
+// src/validate-extend-host-free.ts
+function readSoleBlockItem(text) {
+  const tokens = tokenize(text);
+  if (tokens.length === 0 || isInert(tokens[0])) return void 0;
+  const closerFor = matchBrackets(tokens);
+  const item = readItem(tokens, 0, tokens.length, closerFor);
+  if (item.end !== tokens.length || item.blockStart === void 0) return void 0;
+  const last = tokens.length - 1;
+  if (item.blockEnd !== last || tokens[last].type !== "}-token") return void 0;
+  if (closerFor[item.blockStart - 1] !== last) return void 0;
+  return { item, wrapped: { tokens, closerFor } };
+}
+function isValueRoundTrip(wrapped, from, to, isCustom) {
+  const { tokens } = wrapped;
+  if (hasBrokenString(tokens, from, to)) return false;
+  if (isCustom) return true;
+  const last = lastNonWhitespace(tokens, from, to);
+  if (last >= from && tokens[last].type === "comment") return false;
+  return !hasTopLevelColon(wrapped, from, to);
+}
+function isSoleDeclaration(wrapped, start, end, prop) {
+  const { tokens, closerFor } = wrapped;
+  const name = tokens[start];
+  if (name?.type !== "ident-token" || name.raw !== prop) return false;
+  if (tokens[start + 1]?.type !== "colon-token") return false;
+  const declaration = readItem(tokens, start, end, closerFor);
+  if (declaration.kind !== "declaration") return false;
+  if (tokens[declaration.end - 1].type === "semicolon-token") return false;
+  if (!isOnlyInert(tokens, declaration.end, end)) return false;
+  return isValueRoundTrip(wrapped, start + 2, end, prop.startsWith("--"));
+}
+function isReadTwoWays(prop, value) {
+  return hasEscapedCommentOpener(prop) || hasEscapedCommentOpener(value) || hasEscapedWhitespace(prop);
+}
+function isRewrittenByPostcss(prop, value) {
+  if (hasHtmlBreakout(prop) || hasHtmlBreakout(value)) return true;
+  if (hasUnstrippedTrailingSpace(prop) || hasUnstrippedTrailingSpace(value)) return true;
+  return prop.startsWith("--") && value !== value.trimEnd();
+}
+function declarationRefusal(prop, value) {
+  if (isReadTwoWays(prop, value)) return "break-out";
+  const sole = readSoleBlockItem(`a{${prop}:${value}}`);
+  if (sole?.item.kind !== "rule") return "break-out";
+  const { blockStart, blockEnd } = sole.item;
+  if (!isSoleDeclaration(sole.wrapped, blockStart, blockEnd, prop)) return "break-out";
+  return isRewrittenByPostcss(prop, value) ? "rewritten" : void 0;
+}
+function propRefusal(prop) {
+  return declarationRefusal(prop, "0");
+}
+function isPreludeUnambiguous(wrapped, from, to) {
+  const { tokens } = wrapped;
+  return !hasPaddedComment(tokens, from, to) && !hasBrokenString(tokens, from, to) && !hasUrl(tokens, from, to) && !hasStrayCurlyCloser(wrapped, from, to);
+}
+function anchoredSelector(key) {
+  let selector;
+  try {
+    selector = anchorSelectorList(key);
+  } catch {
+    return void 0;
+  }
+  const isUnreadable = selector.startsWith("@") || selector.startsWith("--") || hasEscapedCommentOpener(selector);
+  return isUnreadable ? void 0 : selector;
+}
+function selectorRefusal(key) {
+  const selector = anchoredSelector(key);
+  if (selector === void 0) return "break-out";
+  const sole = readSoleBlockItem(`${selector}{}`);
+  if (sole?.item.kind !== "rule") return "break-out";
+  const { tokens } = sole.wrapped;
+  const { blockStart, blockEnd } = sole.item;
+  const prelude = blockStart - 1;
+  const isOneEmptyRule = isOnlyInert(tokens, blockStart, blockEnd) && tokens[lastNonWhitespace(tokens, 0, prelude)]?.type !== "comment" && isPreludeUnambiguous(sole.wrapped, 0, prelude);
+  return isOneEmptyRule ? void 0 : "break-out";
+}
+function conditionRefusal(atName, condition) {
+  if (hasEscapedCommentOpener(condition)) return "break-out";
+  const sole = readSoleBlockItem(`@${atName} ${condition}{}`);
+  if (sole?.item.kind !== "at-rule" || sole.item.atKeyword !== atName) return "break-out";
+  const { blockStart, blockEnd } = sole.item;
+  const prelude = blockStart - 1;
+  const isOneBodilessRule = isOnlyInert(sole.wrapped.tokens, blockStart, blockEnd) && !hasTopLevelComment(sole.wrapped, 1, prelude) && isPreludeUnambiguous(sole.wrapped, 1, prelude);
+  if (!isOneBodilessRule) return "break-out";
+  const isUntrimmed = hasUnstrippedTrailingSpace(condition) || hasUnstrippedLeadingSpace(condition);
+  return isUntrimmed ? "rewritten" : void 0;
+}
+function validateExtendAtomsHostFree(extend) {
+  walkExtendAtoms(extend, { declarationRefusal, propRefusal, selectorRefusal, conditionRefusal });
+}
+
+export { validateExtendAtomsHostFree };