@publish.os/nextjs 0.0.1-alpha.90 → 0.0.1-alpha.91

package/dist/capture-local-source-WGGDIUU2.js

@@ -0,0 +1,258 @@
+import {
+  assertPublishOsSourceBoundary
+} from "./chunk-7NY22B5U.js";
+import {
+  decodeCssPath,
+  ignoredMediaDocumentWarning,
+  mediaFileByteLimit,
+  readBoundedMediaFile,
+  themeResourceByteLimit
+} from "./chunk-5KAD7W53.js";
+import {
+  isExcludedSourcePath
+} from "./chunk-WL75GQ5M.js";
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/lifecycle/capture-local-source.ts
+import { createHash } from "crypto";
+import { constants } from "fs";
+import {
+  lstat,
+  mkdir,
+  open,
+  readdir,
+  readFile,
+  realpath,
+  writeFile
+} from "fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import valueParser from "postcss-value-parser";
+function isInside({ root, path }) {
+  let value = relative(root, path);
+  return value !== "" && value !== ".." && !value.startsWith(`..${sep}`) && !isAbsolute(value);
+}
+function cssResourcePaths(css) {
+  let paths = /* @__PURE__ */ new Set();
+  return valueParser(css).walk((node) => {
+    if (node.type !== "function") return;
+    let name = node.value.toLowerCase(), candidates = name === "url" ? node.nodes.filter(
+      (child) => child.type === "string" || child.type === "word"
+    ) : ["image-set", "-webkit-image-set"].includes(name) ? node.nodes.filter((child) => child.type === "string") : [];
+    for (let candidate of candidates) {
+      let decoded = decodeCssPath(candidate.value.trim());
+      if (!decoded || decoded.startsWith("#") || decoded.startsWith("/") || decoded.startsWith("//") || /^[a-z][a-z0-9+.-]*:/iu.test(decoded))
+        continue;
+      let path = decoded.split(/[?#]/u, 1)[0] ?? "";
+      path && paths.add(path);
+    }
+    if (name === "url") return !1;
+  }), [...paths];
+}
+async function collectCssReferencedResources({
+  captureDir,
+  capturedFiles
+}) {
+  let referenced = /* @__PURE__ */ new Set();
+  for (let cssFile of capturedFiles.filter(
+    (path) => path.toLowerCase().endsWith(".css")
+  )) {
+    let css = await readFile(join(captureDir, cssFile), "utf8");
+    for (let urlPath of cssResourcePaths(css)) {
+      let absolutePath = resolve(captureDir, dirname(cssFile), urlPath);
+      isInside({ root: captureDir, path: absolutePath }) && referenced.add(relative(captureDir, absolutePath).split(sep).join("/"));
+    }
+  }
+  return referenced;
+}
+function localFontPaths(config) {
+  if (!config || typeof config != "object" || Array.isArray(config)) return [];
+  let fonts = config.fonts;
+  if (!fonts || typeof fonts != "object" || Array.isArray(fonts)) return [];
+  let paths = /* @__PURE__ */ new Set();
+  for (let role of Object.values(fonts)) {
+    if (!role || typeof role != "object" || Array.isArray(role)) continue;
+    let src = role.src, addPath = (value) => {
+      if (typeof value != "string" || /^[a-z][a-z0-9+.-]*:/iu.test(value) || value.startsWith("//") || value.includes("\0"))
+        return;
+      let normalized = value.replace(/^\/+/, "").replace(/^\.\//, "");
+      normalized && paths.add(normalized);
+    };
+    if (addPath(src), Array.isArray(src))
+      for (let file of src)
+        file && typeof file == "object" && !Array.isArray(file) && addPath(file.path);
+  }
+  return [...paths];
+}
+async function collectConfiguredFontResources({
+  captureDir,
+  capturedFiles
+}) {
+  let referenced = /* @__PURE__ */ new Set();
+  for (let configPath of capturedFiles.filter(
+    (path) => path.endsWith(".config.json")
+  )) {
+    let config;
+    try {
+      config = JSON.parse(await readFile(join(captureDir, configPath), "utf8"));
+    } catch {
+      continue;
+    }
+    for (let fontPath of localFontPaths(config)) {
+      let absolutePath = resolve(captureDir, fontPath);
+      isInside({ root: captureDir, path: absolutePath }) && referenced.add(relative(captureDir, absolutePath).split(sep).join("/"));
+    }
+  }
+  return referenced;
+}
+async function readUnboundedSourceFile({
+  path,
+  entry,
+  signal
+}) {
+  let file = await open(
+    path,
+    constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0)
+  );
+  try {
+    let opened = await file.stat();
+    if (!opened.isFile() || opened.dev !== entry.dev || opened.ino !== entry.ino)
+      throw new AppError({
+        code: "FRAMEWORK_CAPTURE_SOURCE_CHANGED",
+        message: "A source entry changed before capture could read it."
+      });
+    signal?.throwIfAborted();
+    let contents = await file.readFile({ signal });
+    return signal?.throwIfAborted(), contents;
+  } finally {
+    await file.close();
+  }
+}
+async function captureLocalSource({
+  sourceRoot,
+  captureDir,
+  signal
+}) {
+  signal?.throwIfAborted(), await assertPublishOsSourceBoundary(sourceRoot), signal?.throwIfAborted();
+  let root = await realpath(sourceRoot), destination = resolve(captureDir), outputRoot = join(root, ".publish.os");
+  if (!isInside({ root: outputRoot, path: destination }) || await realpath(dirname(destination)) !== dirname(destination))
+    throw new AppError({
+      code: "FRAMEWORK_CAPTURE_OUTPUT_INVALID",
+      message: "Source capture requires an owned path inside source output."
+    });
+  await mkdir(destination).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  let destinationEntry = await lstat(destination);
+  if (!destinationEntry.isDirectory() || destinationEntry.isSymbolicLink() || await realpath(destination) !== destination || (await readdir(destination)).length > 0)
+    throw new AppError({
+      code: "FRAMEWORK_CAPTURE_OUTPUT_INVALID",
+      message: "Source capture requires an empty owned directory."
+    });
+  let capturedFiles = [], deferredResources = [], copyDirectory = async (relativeDirectory) => {
+    signal?.throwIfAborted();
+    let directory = join(root, relativeDirectory), names = (await readdir(directory)).sort();
+    if (!relativeDirectory) {
+      let configIndex = names.indexOf("publish.os.config.json");
+      if (configIndex > 0) {
+        let [configName] = names.splice(configIndex, 1);
+        configName && names.unshift(configName);
+      }
+    }
+    for (let name of names) {
+      signal?.throwIfAborted();
+      let path = relativeDirectory ? `${relativeDirectory}/${name}` : name;
+      if (isExcludedSourcePath(path) || relativeDirectory === "" && name.startsWith(".env"))
+        continue;
+      let sourcePath = join(root, path), outputPath = join(destination, path), entry = await lstat(sourcePath);
+      if (entry.isSymbolicLink())
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_SYMLINK",
+          message: "Symbolic links are not allowed inside publish.os."
+        });
+      if (!isInside({ root, path: await realpath(sourcePath) }))
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_PATH_ESCAPE",
+          message: "A source entry resolves outside the selected source."
+        });
+      if (entry.isDirectory()) {
+        await mkdir(outputPath), await copyDirectory(path);
+        continue;
+      }
+      if (!entry.isFile())
+        throw new AppError({
+          code: "FRAMEWORK_SOURCE_ENTRY_NOT_REGULAR",
+          message: "Source capture accepts only directories and regular files."
+        });
+      let contents;
+      if (ignoredMediaDocumentWarning(path))
+        contents = Buffer.alloc(0);
+      else if (path.startsWith("assets/")) {
+        let relativeAssetPath = path.slice(7);
+        contents = await readBoundedMediaFile({
+          path: sourcePath,
+          relativePath: `assets/${relativeAssetPath}`,
+          limit: mediaFileByteLimit(relativeAssetPath),
+          expectedIdentity: { dev: entry.dev, ino: entry.ino },
+          signal
+        });
+      } else if (themeResourceByteLimit(path) !== void 0) {
+        deferredResources.push({
+          path: sourcePath,
+          outputPath,
+          relativePath: path,
+          entry
+        });
+        continue;
+      } else
+        contents = await readUnboundedSourceFile({
+          path: sourcePath,
+          entry,
+          signal
+        });
+      await writeFile(outputPath, contents, { flag: "wx", signal }), capturedFiles.push(path);
+    }
+  };
+  await copyDirectory("");
+  let cssResources = await collectCssReferencedResources({
+    captureDir: destination,
+    capturedFiles
+  });
+  for (let path of await collectConfiguredFontResources({
+    captureDir: destination,
+    capturedFiles
+  }))
+    cssResources.add(path);
+  for (let resource of deferredResources) {
+    signal?.throwIfAborted();
+    let contents = cssResources.has(resource.relativePath) ? await readBoundedMediaFile({
+      path: resource.path,
+      relativePath: resource.relativePath,
+      limit: themeResourceByteLimit(resource.relativePath) ?? 0,
+      expectedIdentity: {
+        dev: resource.entry.dev,
+        ino: resource.entry.ino
+      },
+      signal
+    }) : await readUnboundedSourceFile({
+      path: resource.path,
+      entry: resource.entry,
+      signal
+    });
+    await writeFile(resource.outputPath, contents, { flag: "wx", signal }), capturedFiles.push(resource.relativePath);
+  }
+  let hash = createHash("sha256");
+  for (let path of capturedFiles.sort()) {
+    signal?.throwIfAborted();
+    let contents = await readFile(join(destination, path), { signal });
+    hash.update(JSON.stringify([path, contents.byteLength])), hash.update("\0"), hash.update(contents);
+  }
+  return signal?.throwIfAborted(), {
+    sourceDir: captureDir,
+    sourceRevision: `sha256:${hash.digest("hex")}`
+  };
+}
+export {
+  captureLocalSource
+};

package/dist/chunk-22RSSUNV.js

@@ -0,0 +1,13 @@
+// src/lib/compiler/internal/errors.ts
+var AppError = class extends Error {
+  code;
+  details;
+  fix;
+  constructor({ code, message, details, fix }) {
+    super(message), this.name = "FrameworkError", this.code = code, this.details = details, this.fix = fix;
+  }
+};
+
+export {
+  AppError
+};

package/dist/{chunk-WKTEO6RS.js → chunk-4BC2L2KA.js}

@@ -1,6 +1,6 @@
 import {
   AppError
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/lifecycle/local-process.ts
 import { spawn as spawn2 } from "child_process";
@@ -336,6 +336,9 @@ var LocalProcessError = class extends AppError {
     }), this.output = output;
   }
 };
+async function processGroupAbsentAfterReapTurn(groupExists) {
+  return await new Promise((resolve) => setImmediate(resolve)), !groupExists();
+}
 function startLocalProcess(options) {
   options.signal.throwIfAborted();
   let grouped = process.platform !== "win32", environment = options.environment ?? localProcessEnvironment({ mode: "production" }), windows = grouped ? void 0 : startWindowsProcess({
@@ -399,7 +402,10 @@ function startLocalProcess(options) {
       killGroup("SIGTERM");
       let forced = !1;
       for (; groupExists(); ) {
-        if (!forced && Date.now() >= deadline - 750 && (killGroup("SIGKILL"), forced = !0), Date.now() >= deadline) throw shutdownFailure();
+        if (!forced && Date.now() >= deadline - 750 && (killGroup("SIGKILL"), forced = !0), Date.now() >= deadline) {
+          if (await processGroupAbsentAfterReapTurn(groupExists)) break;
+          throw shutdownFailure();
+        }
         await new Promise((resolve) => setTimeout(resolve, 20));
       }
     }
@@ -470,9 +476,7 @@ async function installLocalApp({
   outputDir,
   framework,
   options,
-  lifetime,
-  purpose,
-  assertInstallGraph
+  lifetime
 }) {
   let publicCommand = options.request.operation === "validate" ? "init" : options.request.operation, command = options.request.context?.pnpmExecutable;
   if (typeof command != "string" || !isAbsolute(command))
@@ -525,7 +529,7 @@ async function installLocalApp({
   let lockPath = join2(outputDir, "pnpm-lock.yaml"), lock = await readFile(lockPath);
   options.onEvent?.({
     type: "progress",
-    message: purpose === "ide" ? "Preparing IDE dependencies" : "Preparing app dependencies"
+    message: "Preparing app dependencies"
   });
   try {
     await run({
@@ -542,13 +546,13 @@ async function installLocalApp({
       throw error instanceof LocalProcessError && error.output.trim() && process.stderr.write(error.output), error;
     options.onEvent?.({
       type: "progress",
-      message: `Downloading missing ${purpose === "ide" ? "IDE" : "app"} dependencies`
-    }), await assertInstallGraph?.();
+      message: "Downloading missing app dependencies"
+    });
     try {
       await run({
-        args: ["install", "--frozen-lockfile", "--fetch-timeout=10000"],
+        args: ["install", "--frozen-lockfile"],
         quiet: options.request.operation !== "build",
-        timeoutMs: 12e4
+        timeoutMs: 3e5
       });
     } catch (downloadError) {
       throw downloadError instanceof AppError && downloadError.code === "FRAMEWORK_PROCESS_SHUTDOWN_FAILED" || (lifetime.signal.throwIfAborted(), !(downloadError instanceof LocalProcessError) && !(downloadError instanceof AppError && downloadError.code === "FRAMEWORK_DEPENDENCY_DOWNLOAD_FAILED")) ? downloadError : new AppError({
@@ -557,7 +561,7 @@ async function installLocalApp({
       });
     }
   }
-  if (await assertInstallGraph?.(), !(await readFile(lockPath)).equals(lock))
+  if (!(await readFile(lockPath)).equals(lock))
     throw new AppError({
       code: "FRAMEWORK_RELEASE_INVALID",
       message: "App installation changed the released lock. The output was not published."
@@ -578,9 +582,39 @@ async function installLocalApp({
   return { run: (args) => run({ args }) };
 }
 
+// src/lib/compiler/lifecycle/local-gates.ts
+async function requestLocalGate({
+  options,
+  gate
+}) {
+  options.signal?.throwIfAborted();
+  let approved = await new Promise((resolve, reject) => {
+    let abort = () => reject(options.signal?.reason);
+    options.signal?.addEventListener("abort", abort, { once: !0 }), options.signal?.aborted && abort(), Promise.resolve().then(() => options.onGate?.(gate)).then((value) => resolve(value === !0), reject).finally(() => options.signal?.removeEventListener("abort", abort));
+  });
+  if (options.signal?.throwIfAborted(), !approved)
+    throw new AppError({
+      code: "FRAMEWORK_GATE_DENIED",
+      message: "The caller did not authorize the operation."
+    });
+}
+async function approveLocalComposition({
+  options
+}) {
+  options.onGate && await requestLocalGate({
+    options,
+    gate: {
+      id: "compose",
+      kind: "compose",
+      summary: "Compose the validated source."
+    }
+  });
+}
+
 export {
   localProcessEnvironment,
   LocalProcessError,
   startLocalProcess,
-  installLocalApp
+  installLocalApp,
+  approveLocalComposition
 };

package/dist/{chunk-WDY4IK6Z.js → chunk-5J3YUNRY.js}

@@ -1,12 +1,6 @@
-// src/lib/compiler/internal/errors.ts
-var AppError = class extends Error {
-  code;
-  details;
-  fix;
-  constructor({ code, message, details, fix }) {
-    super(message), this.name = "FrameworkError", this.code = code, this.details = details, this.fix = fix;
-  }
-};
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/release/installed-framework.ts
 import { readFileSync } from "fs";
@@ -122,7 +116,6 @@ async function readInstalledFramework() {
 }
 
 export {
-  AppError,
   readInstalledFrameworkLocation,
   readInstalledFramework
 };

package/dist/chunk-5KAD7W53.js

@@ -0,0 +1,248 @@
+import {
+  AppError
+} from "./chunk-22RSSUNV.js";
+
+// src/lib/compiler/source/assets/media-file-policy.ts
+import { constants as fsConstants } from "fs";
+import { open } from "fs/promises";
+var DEFAULT_MAX_IMAGE_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_VIDEO_BYTES = 20 * 1024 * 1024, DEFAULT_MAX_OTHER_BYTES = 5 * 1024 * 1024, MAX_THEME_FONT_BYTES = DEFAULT_MAX_OTHER_BYTES, MAX_MEDIA_SVG_BYTES = 256 * 1024, IGNORED_DOCUMENT_EXTENSIONS = /* @__PURE__ */ new Set(["pdf", "txt", "csv", "zip"]), THEME_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "avif",
+  "ico",
+  "svg"
+]), THEME_FONT_EXTENSIONS = /* @__PURE__ */ new Set(["woff", "woff2", "ttf", "otf"]);
+function ignoredMediaDocumentWarning(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "";
+  if (IGNORED_DOCUMENT_EXTENSIONS.has(extension))
+    return {
+      code: "FRAMEWORK_MEDIA_DOCUMENT_IGNORED",
+      message: `${relativePath} is ignored because this file type is not supported.`,
+      details: { file: relativePath, path: relativePath }
+    };
+}
+function ignoredMediaPathWarning(sourcePath) {
+  return {
+    code: "FRAMEWORK_MEDIA_PATH_IGNORED",
+    message: "Hidden media file ignored.",
+    details: { file: sourcePath, path: sourcePath }
+  };
+}
+function isHiddenMediaPath(sourcePath) {
+  return sourcePath.split(/[\\/]/u).some((segment) => segment.startsWith("."));
+}
+function mediaFileTooLarge(options) {
+  return new AppError({
+    code: "FRAMEWORK_MEDIA_FILE_TOO_LARGE",
+    message: `${options.relativePath} is ${options.bytes} bytes. Media files must be less than ${Math.round(options.limit / 1024 / 1024)} MB.`,
+    details: {
+      path: options.relativePath,
+      bytes: options.bytes,
+      limit: options.limit
+    }
+  });
+}
+function mediaFileByteLimit(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "", imageLimit = DEFAULT_MAX_IMAGE_BYTES;
+  return ["png", "jpg", "jpeg", "gif", "webp", "avif", "ico"].includes(extension) ? imageLimit : extension === "svg" ? Math.min(imageLimit, MAX_MEDIA_SVG_BYTES) : ["mp4", "webm"].includes(extension) ? DEFAULT_MAX_VIDEO_BYTES : DEFAULT_MAX_OTHER_BYTES;
+}
+function themeResourceByteLimit(relativePath) {
+  let extension = relativePath.split(".").at(-1)?.toLowerCase() ?? "";
+  if (THEME_FONT_EXTENSIONS.has(extension)) return MAX_THEME_FONT_BYTES;
+  if (THEME_IMAGE_EXTENSIONS.has(extension))
+    return mediaFileByteLimit(relativePath);
+}
+async function readBoundedMediaFile(options) {
+  let handle = await (options.openFile ?? open)(
+    options.path,
+    fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0) | (fsConstants.O_NONBLOCK ?? 0)
+  );
+  try {
+    let opened = await handle.stat();
+    if (!opened.isFile() || options.expectedIdentity !== void 0 && (opened.dev !== options.expectedIdentity.dev || opened.ino !== options.expectedIdentity.ino))
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_FILE_CHANGED",
+        message: `${options.relativePath} changed while media was being read`,
+        details: { path: options.relativePath }
+      });
+    if (opened.size > options.limit)
+      throw mediaFileTooLarge({
+        relativePath: options.relativePath,
+        bytes: opened.size,
+        limit: options.limit
+      });
+    let chunkSize = Math.min(64 * 1024, options.limit + 1), chunk = Buffer.allocUnsafe(Math.max(1, chunkSize)), chunks = [], bytesRead = 0;
+    for (; ; ) {
+      options.signal?.throwIfAborted();
+      let remainingWithOverflowProbe = options.limit - bytesRead + 1, { bytesRead: count } = await handle.read(
+        chunk,
+        0,
+        Math.min(chunk.length, remainingWithOverflowProbe),
+        null
+      );
+      if (options.signal?.throwIfAborted(), count === 0) break;
+      if (bytesRead += count, bytesRead > options.limit)
+        throw mediaFileTooLarge({
+          relativePath: options.relativePath,
+          bytes: bytesRead,
+          limit: options.limit
+        });
+      chunks.push(Buffer.from(chunk.subarray(0, count)));
+    }
+    let completed = await handle.stat();
+    if (completed.size > options.limit)
+      throw mediaFileTooLarge({
+        relativePath: options.relativePath,
+        bytes: completed.size,
+        limit: options.limit
+      });
+    if (completed.size !== bytesRead)
+      throw new AppError({
+        code: "FRAMEWORK_MEDIA_FILE_CHANGED",
+        message: `${options.relativePath} changed while media was being read`,
+        details: { path: options.relativePath }
+      });
+    return Buffer.concat(chunks, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/lib/compiler/source/css-imports.ts
+function skipString(css, start) {
+  let quote = css[start];
+  for (let index = start + 1; index < css.length; index += 1)
+    if (css[index] === "\\") index += 1;
+    else if (css[index] === quote) return index + 1;
+  return css.length;
+}
+function maskComments(css) {
+  let result = "";
+  for (let index = 0; index < css.length; )
+    if (css[index] === '"' || css[index] === "'") {
+      let end = skipString(css, index);
+      result += css.slice(index, end), index = end;
+    } else if (css.startsWith("/*", index)) {
+      let closing = css.indexOf("*/", index + 2), end = closing < 0 ? css.length : closing + 2;
+      result += css.slice(index, end).replace(/[^\r\n]/g, " "), index = end;
+    } else
+      result += css[index], index += 1;
+  return result;
+}
+function decodeCssPath(value) {
+  return value.replace(/\\(?:\r\n|[\r\n\f])/g, "").replace(
+    /\\([\da-f]{1,6})[\t\n\f\r ]?|\\(.)/gi,
+    (_match, hex, escaped) => {
+      if (!hex) return escaped ?? "";
+      let codePoint = Number.parseInt(hex, 16);
+      return codePoint > 0 && codePoint <= 1114111 && !(codePoint >= 55296 && codePoint <= 57343) ? String.fromCodePoint(codePoint) : "\uFFFD";
+    }
+  );
+}
+function statementEnd(scan, start) {
+  let depth = 0;
+  for (let index = start; index < scan.length; index += 1)
+    if (scan[index] === '"' || scan[index] === "'")
+      index = skipString(scan, index) - 1;
+    else if (scan[index] === "\\")
+      index += 1;
+    else if (scan[index] === "(")
+      depth += 1;
+    else if (scan[index] === ")")
+      depth -= 1;
+    else {
+      if (scan[index] === ";" && depth === 0)
+        return index + 1;
+      if ((scan[index] === "{" || scan[index] === "}") && depth === 0)
+        return index;
+    }
+  return scan.length;
+}
+function closingParenthesis(scan, start, end) {
+  let depth = 0;
+  for (let index = start; index < end; index += 1)
+    if (scan[index] === '"' || scan[index] === "'")
+      index = skipString(scan, index) - 1;
+    else if (scan[index] === "\\")
+      index += 1;
+    else if (scan[index] === "(")
+      depth += 1;
+    else if (scan[index] === ")" && --depth === 0)
+      return index;
+  return end;
+}
+function importConditions({
+  css,
+  scan,
+  start,
+  end
+}) {
+  let result = {}, tailEnd = scan[end - 1] === ";" ? end - 1 : end, cursor = start, skipWhitespace = () => {
+    for (; cursor < tailEnd && /\s/.test(scan[cursor] ?? ""); ) cursor += 1;
+  };
+  skipWhitespace();
+  let layer = /^layer(?=\(|\s|$)/i.exec(scan.slice(cursor, tailEnd));
+  if (layer) {
+    if (cursor += layer[0].length, scan[cursor] === "(") {
+      let closing = closingParenthesis(scan, cursor, tailEnd);
+      result.layer = css.slice(cursor + 1, closing).trim(), cursor = closing + 1;
+    } else
+      result.layer = !0;
+    skipWhitespace();
+  }
+  let supports = /^supports\(/i.exec(scan.slice(cursor, tailEnd));
+  if (supports) {
+    let opening = cursor + supports[0].length - 1, closing = closingParenthesis(scan, opening, tailEnd);
+    result.supports = css.slice(opening + 1, closing).trim(), cursor = closing + 1, skipWhitespace();
+  }
+  return scan.slice(cursor, tailEnd).trim() && (result.media = css.slice(cursor, tailEnd).trim()), result;
+}
+function cssImports({ css }) {
+  let scan = maskComments(css), pattern = /@import\s+(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|url\(\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^\s)]+))\s*\))/giy, imports = [];
+  for (let index = 0; index < scan.length; ) {
+    if (scan[index] === '"' || scan[index] === "'") {
+      index = skipString(scan, index);
+      continue;
+    }
+    if (scan[index] === "\\") {
+      index += 2;
+      continue;
+    }
+    pattern.lastIndex = index;
+    let match = scan[index] === "@" ? pattern.exec(scan) : null;
+    if (!match) {
+      index += 1;
+      continue;
+    }
+    let path = decodeCssPath(
+      match.slice(1).find((value) => value !== void 0) ?? ""
+    ), end = statementEnd(scan, pattern.lastIndex);
+    imports.push({
+      path,
+      start: index,
+      end,
+      ...importConditions({ css, scan, start: pattern.lastIndex, end })
+    }), index = end;
+  }
+  return imports;
+}
+function localCssImports({ css }) {
+  return cssImports({ css }).filter(({ path }) => path.startsWith("."));
+}
+
+export {
+  MAX_MEDIA_SVG_BYTES,
+  ignoredMediaDocumentWarning,
+  ignoredMediaPathWarning,
+  isHiddenMediaPath,
+  mediaFileTooLarge,
+  mediaFileByteLimit,
+  themeResourceByteLimit,
+  readBoundedMediaFile,
+  decodeCssPath,
+  cssImports,
+  localCssImports
+};

package/dist/{chunk-DWA3ZRGW.js → chunk-6C65KV7O.js}

@@ -3,10 +3,10 @@ import {
   assertLocalDirectory,
   assertOperationOutput,
   markOperationOutput
-} from "./chunk-GGKFQ3MA.js";
+} from "./chunk-6D2E6UMD.js";
 import {
   AppError
-} from "./chunk-WDY4IK6Z.js";
+} from "./chunk-22RSSUNV.js";
 
 // src/lib/compiler/lifecycle/checkout-preparation.ts
 import { lstat, mkdir, readdir, realpath } from "fs/promises";