portapack 0.3.0 → 0.3.1

package/dist/index.js

@@ -194,7 +194,6 @@ function isUtf8DecodingLossy(originalBuffer, decodedString) {
   }
 }
 function determineBaseUrl(inputPathOrUrl, logger) {
-  console.log(`[DEBUG determineBaseUrl] Input: "${inputPathOrUrl}"`);
   logger?.debug(`Determining base URL for input: ${inputPathOrUrl}`);
   if (!inputPathOrUrl) {
     logger?.warn("Cannot determine base URL: inputPathOrUrl is empty or invalid.");
@@ -208,11 +207,9 @@ function determineBaseUrl(inputPathOrUrl, logger) {
       url.hash = "";
       const baseUrl = url.href;
       logger?.debug(`Determined remote base URL: ${baseUrl}`);
-      console.log(`[DEBUG determineBaseUrl] Determined Remote URL: "${baseUrl}"`);
       return baseUrl;
     } else if (inputPathOrUrl.includes("://") && !inputPathOrUrl.startsWith("file:")) {
       logger?.warn(`Input "${inputPathOrUrl}" looks like a URL but uses an unsupported protocol. Cannot determine base URL.`);
-      console.log(`[DEBUG determineBaseUrl] Unsupported protocol.`);
       return void 0;
     } else {
       let resourcePath;
@@ -228,9 +225,7 @@ function determineBaseUrl(inputPathOrUrl, logger) {
           isInputLikelyDirectory = false;
         }
       }
-      console.log(`[DEBUG determineBaseUrl] resourcePath: "${resourcePath}", isInputLikelyDirectory: ${isInputLikelyDirectory}`);
       const baseDirPath = isInputLikelyDirectory ? resourcePath : path2.dirname(resourcePath);
-      console.log(`[DEBUG determineBaseUrl] Calculated baseDirPath: "${baseDirPath}"`);
       let normalizedPathForURL = baseDirPath.replace(/\\/g, "/");
       if (/^[A-Z]:\//i.test(normalizedPathForURL) && !normalizedPathForURL.startsWith("/")) {
         normalizedPathForURL = "/" + normalizedPathForURL;
@@ -241,12 +236,10 @@ function determineBaseUrl(inputPathOrUrl, logger) {
       const fileUrl = new URL2("file://" + normalizedPathForURL);
       const fileUrlString = fileUrl.href;
       logger?.debug(`Determined base URL: ${fileUrlString} (from: ${inputPathOrUrl}, resolved base dir: ${baseDirPath})`);
-      console.log(`[DEBUG determineBaseUrl] Determined File URL: "${fileUrlString}"`);
       return fileUrlString;
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    console.error(`[DEBUG determineBaseUrl] Error determining base URL: ${message}`);
     logger?.error(`\u{1F480} Failed to determine base URL for "${inputPathOrUrl}": ${message}${error instanceof Error && error.stack ? ` - Stack: ${error.stack}` : ""}`);
     return void 0;
   }
@@ -284,82 +277,69 @@ function resolveAssetUrl(assetUrl, baseContextUrl, logger) {
   }
 }
 function resolveCssRelativeUrl(relativeUrl, cssBaseContextUrl, logger) {
-  console.log(`[DEBUG resolveCssRelativeUrl] Input: relative="${relativeUrl}", base="${cssBaseContextUrl}"`);
   if (!relativeUrl || relativeUrl.startsWith("data:") || relativeUrl.startsWith("#")) {
     return null;
   }
   try {
     const resolvedUrl = new URL2(relativeUrl, cssBaseContextUrl);
-    console.log(`[DEBUG resolveCssRelativeUrl] Resolved URL object href: "${resolvedUrl.href}"`);
     return resolvedUrl.href;
   } catch (error) {
     logger?.warn(
       `Failed to resolve CSS URL: "${relativeUrl}" relative to "${cssBaseContextUrl}": ${String(error)}`
     );
-    console.error(`[DEBUG resolveCssRelativeUrl] Error resolving: ${String(error)}`);
     return null;
   }
 }
 async function fetchAsset(resolvedUrl, logger, timeout = 1e4) {
-  console.log(`[DEBUG fetchAsset] Attempting fetch for URL: ${resolvedUrl.href}`);
   logger?.debug(`Attempting to fetch asset: ${resolvedUrl.href}`);
   const protocol = resolvedUrl.protocol;
   try {
     if (protocol === "http:" || protocol === "https:") {
       const response = await axiosNs.default.get(resolvedUrl.href, {
         responseType: "arraybuffer",
+        // Fetch as binary data
         timeout
+        // Apply network timeout
       });
       logger?.debug(`Workspaceed remote asset ${resolvedUrl.href} (Status: ${response.status}, Type: ${response.headers["content-type"] || "N/A"}, Size: ${response.data?.byteLength ?? 0} bytes)`);
-      console.log(`[DEBUG fetchAsset] HTTP fetch SUCCESS for: ${resolvedUrl.href}, Status: ${response.status}`);
       return Buffer.from(response.data);
     } else if (protocol === "file:") {
       let filePath;
       try {
         filePath = fileURLToPath(resolvedUrl);
       } catch (e) {
-        console.error(`[DEBUG fetchAsset] fileURLToPath FAILED for: ${resolvedUrl.href}`, e);
         logger?.error(`Could not convert file URL to path: ${resolvedUrl.href}. Error: ${e.message}`);
         return null;
       }
       const normalizedForLog = path2.normalize(filePath);
-      console.log(`[DEBUG fetchAsset] Attempting readFile with path: "${normalizedForLog}" (Original from URL: "${filePath}")`);
       const data = await readFile(filePath);
-      console.log(`[DEBUG fetchAsset] readFile call SUCCEEDED for path: "${normalizedForLog}". Data length: ${data?.byteLength}`);
       logger?.debug(`Read local file ${filePath} (${data.byteLength} bytes)`);
       return data;
     } else {
-      console.log(`[DEBUG fetchAsset] Unsupported protocol: ${protocol}`);
       logger?.warn(`Unsupported protocol "${protocol}" in URL: ${resolvedUrl.href}`);
       return null;
     }
   } catch (error) {
     const failedId = protocol === "file:" ? path2.normalize(fileURLToPath(resolvedUrl)) : resolvedUrl.href;
-    console.error(`[DEBUG fetchAsset] fetch/read FAILED for: "${failedId}". Error:`, error);
-    if ((protocol === "http:" || protocol === "https:") && axiosNs.isAxiosError(error)) {
-      const status = error.response?.status ?? "N/A";
-      const statusText = error.response?.statusText ?? "Error";
-      const code = error.code ?? "N/A";
-      const message = error.message;
-      const logMessage = `\u26A0\uFE0F Failed to fetch remote asset ${resolvedUrl.href}: Status ${status} - ${statusText}. Code: ${code}, Message: ${message}`;
+    if ((protocol === "http:" || protocol === "https:") && error?.isAxiosError === true) {
+      const axiosError = error;
+      const status = axiosError.response?.status ?? "N/A";
+      const code = axiosError.code ?? "N/A";
+      const logMessage = `\u26A0\uFE0F Failed to fetch remote asset ${resolvedUrl.href}: ${axiosError.message} (Code: ${code})`;
       logger?.warn(logMessage);
-    }
-    if (error instanceof Error && error.code === "ENOENT") {
+    } else if (protocol === "file:" && error instanceof Error) {
       let failedPath = resolvedUrl.href;
       try {
         failedPath = fileURLToPath(resolvedUrl);
       } catch {
       }
       failedPath = path2.normalize(failedPath);
-      if (error instanceof Error && error.code === "ENOENT") {
+      if (error.code === "ENOENT") {
         logger?.warn(`\u26A0\uFE0F File not found (ENOENT) for asset: ${failedPath}.`);
-      } else if (error instanceof Error && error.code === "EACCES") {
+      } else if (error.code === "EACCES") {
         logger?.warn(`\u26A0\uFE0F Permission denied (EACCES) reading asset: ${failedPath}.`);
-        logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
-      } else if (error instanceof Error) {
-        logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
       } else {
-        logger?.warn(`\u26A0\uFE0F An unknown error occurred while reading local asset ${failedPath}: ${String(error)}`);
+        logger?.warn(`\u26A0\uFE0F Failed to read local asset ${failedPath}: ${error.message}`);
       }
     } else if (error instanceof Error) {
       logger?.warn(`\u26A0\uFE0F An unexpected error occurred processing asset ${resolvedUrl.href}: ${error.message}`);
@@ -375,7 +355,7 @@ function extractUrlsFromCSS(cssContent, cssBaseContextUrl, logger) {
   const urlRegex = /url\(\s*(['"]?)(.*?)\1\s*\)/gi;
   const importRegex = /@import\s+(?:url\(\s*(['"]?)(.*?)\1\s*\)|(['"])(.*?)\3)\s*;/gi;
   const processFoundUrl = (rawUrl, ruleType) => {
-    if (!rawUrl || rawUrl.trim() === "" || rawUrl.startsWith("data:")) return;
+    if (!rawUrl || rawUrl.trim() === "" || rawUrl.startsWith("data:") || rawUrl.startsWith("#")) return;
     const resolvedUrl = resolveCssRelativeUrl(rawUrl, cssBaseContextUrl, logger);
     if (resolvedUrl && !processedInThisParse.has(resolvedUrl)) {
       processedInThisParse.add(resolvedUrl);
@@ -383,7 +363,7 @@ function extractUrlsFromCSS(cssContent, cssBaseContextUrl, logger) {
       newlyDiscovered.push({
         type: assetType,
         url: resolvedUrl,
-        // The resolved absolute URL string
+        // Store the resolved absolute URL string
         content: void 0
         // Content will be fetched later if needed
       });
@@ -420,7 +400,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
       continue;
     }
     const urlToQueue = resolvedUrlObj.href;
-    if (!urlToQueue.startsWith("data:") && !processedOrQueuedUrls.has(urlToQueue)) {
+    if (!processedOrQueuedUrls.has(urlToQueue)) {
       processedOrQueuedUrls.add(urlToQueue);
       const { assetType: guessedType } = guessMimeType(urlToQueue);
       const initialType = asset.type ?? guessedType;
@@ -429,10 +409,9 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
         // Use the resolved URL
         type: initialType,
         content: void 0
+        // Content is initially undefined
       });
       logger?.debug(` -> Queued initial asset: ${urlToQueue} (Original raw: ${asset.url})`);
-    } else if (urlToQueue.startsWith("data:")) {
-      logger?.debug(` -> Skipping data URI: ${urlToQueue.substring(0, 50)}...`);
     } else {
       logger?.debug(` -> Skipping already processed/queued initial asset: ${urlToQueue}`);
     }
@@ -552,7 +531,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
           const newlyDiscoveredAssets = extractUrlsFromCSS(
             cssContentForParsing,
             cssBaseContextUrl,
-            // Use CSS file's base URL
+            // Use the CSS file's own URL as the base
             logger
           );
           if (newlyDiscoveredAssets.length > 0) {
@@ -573,7 +552,7 @@ async function extractAssets(parsed, embedAssets = true, inputPathOrUrl, logger)
       }
     }
   }
-  const finalIterationCount = iterationCount > MAX_ASSET_EXTRACTION_ITERATIONS ? "MAX+" : iterationCount;
+  const finalIterationCount = iterationCount > MAX_ASSET_EXTRACTION_ITERATIONS ? `${MAX_ASSET_EXTRACTION_ITERATIONS}+ (limit hit)` : iterationCount;
   logger?.info(`\u2705 Asset extraction COMPLETE! Found ${finalAssetsMap.size} unique assets in ${finalIterationCount} iterations.`);
   return {
     htmlContent: parsed.htmlContent,