@jsenv/ast 3.0.7 → 4.0.0

package/src/js/js_static_analysis/web_worker.js

@@ -1,9 +1,9 @@
-import { isStringLiteralNode } from "./helpers.js"
+import { isStringLiteralNode } from "./helpers.js";
 
 export const isImportScriptsCall = (node) => {
-  const callee = node.callee
+  const callee = node.callee;
   if (callee.type === "Identifier" && callee.name === "importScripts") {
-    return true
+    return true;
   }
   return (
     callee.type === "MemberExpression" &&
@@ -11,12 +11,12 @@ export const isImportScriptsCall = (node) => {
     callee.object.name === "self" &&
     callee.property.type === "Identifier" &&
     callee.property.name === "importScripts"
-  )
-}
+  );
+};
 export const analyzeImportScriptCalls = (node, { onUrl }) => {
   node.arguments.forEach((arg) => {
     if (isStringLiteralNode(arg)) {
-      const specifierNode = arg
+      const specifierNode = arg;
       onUrl({
         type: "js_url",
         subtype: "self_import_scripts_arg",
@@ -26,7 +26,7 @@ export const analyzeImportScriptCalls = (node, { onUrl }) => {
         end: specifierNode.end,
         line: specifierNode.loc.start.line,
         column: specifierNode.loc.start.column,
-      })
+      });
     }
-  })
-}
+  });
+};

package/src/js/js_static_analysis/web_worker_entry_point.js

@@ -1,87 +1,87 @@
-import { getTypePropertyNode, isStringLiteralNode } from "./helpers.js"
-import { isNewUrlCall, analyzeNewUrlCall } from "./new_url.js"
+import { getTypePropertyNode, isStringLiteralNode } from "./helpers.js";
+import { isNewUrlCall, analyzeNewUrlCall } from "./new_url.js";
 import {
   isImportMetaResolveCall,
   analyzeImportMetaResolveCall,
-} from "./import_meta_resolve.js"
+} from "./import_meta_resolve.js";
 
 export const isNewWorkerCall = (node) => {
   return (
     node.type === "NewExpression" &&
     node.callee.type === "Identifier" &&
     node.callee.name === "Worker"
-  )
-}
+  );
+};
 export const analyzeNewWorkerCall = (node, { isJsModule, onUrl }) => {
   analyzeWorkerCallArguments(node, {
     isJsModule,
     onUrl,
     referenceSubtype: "new_worker_first_arg",
     expectedSubtype: "worker",
-  })
-}
+  });
+};
 
 export const isNewSharedWorkerCall = (node) => {
   return (
     node.type === "NewExpression" &&
     node.callee.type === "Identifier" &&
     node.callee.name === "SharedWorker"
-  )
-}
+  );
+};
 export const analyzeNewSharedWorkerCall = (node, { isJsModule, onUrl }) => {
   analyzeWorkerCallArguments(node, {
     isJsModule,
     onUrl,
     referenceSubtype: "new_shared_worker_first_arg",
     expectedSubtype: "shared_worker",
-  })
-}
+  });
+};
 
 export const isServiceWorkerRegisterCall = (node) => {
   if (node.type !== "CallExpression") {
-    return false
+    return false;
   }
-  const callee = node.callee
+  const callee = node.callee;
   if (
     callee.type === "MemberExpression" &&
     callee.property.type === "Identifier" &&
     callee.property.name === "register"
   ) {
-    const parentObject = callee.object
+    const parentObject = callee.object;
     if (parentObject.type === "MemberExpression") {
-      const parentProperty = parentObject.property
+      const parentProperty = parentObject.property;
       if (
         parentProperty.type === "Identifier" &&
         parentProperty.name === "serviceWorker"
       ) {
-        const grandParentObject = parentObject.object
+        const grandParentObject = parentObject.object;
         if (grandParentObject.type === "MemberExpression") {
           // window.navigator.serviceWorker.register
-          const grandParentProperty = grandParentObject.property
+          const grandParentProperty = grandParentObject.property;
           if (
             grandParentProperty.type === "Identifier" &&
             grandParentProperty.name === "navigator"
           ) {
-            const ancestorObject = grandParentObject.object
+            const ancestorObject = grandParentObject.object;
             if (
               ancestorObject.type === "Identifier" &&
               ancestorObject.name === "window"
             ) {
-              return true
+              return true;
             }
           }
         }
         if (grandParentObject.type === "Identifier") {
           // navigator.serviceWorker.register
           if (grandParentObject.name === "navigator") {
-            return true
+            return true;
           }
         }
       }
     }
   }
-  return false
-}
+  return false;
+};
 export const analyzeServiceWorkerRegisterCall = (
   node,
   { isJsModule, onUrl },
@@ -91,32 +91,32 @@ export const analyzeServiceWorkerRegisterCall = (
     onUrl,
     referenceSubtype: "service_worker_register_first_arg",
     expectedSubtype: "service_worker",
-  })
-}
+  });
+};
 
 const analyzeWorkerCallArguments = (
   node,
   { isJsModule, onUrl, referenceSubtype, expectedSubtype },
 ) => {
-  let expectedType = "js_classic"
-  let typePropertyNode
-  const secondArgNode = node.arguments[1]
+  let expectedType = "js_classic";
+  let typePropertyNode;
+  const secondArgNode = node.arguments[1];
   if (secondArgNode) {
-    typePropertyNode = getTypePropertyNode(secondArgNode)
+    typePropertyNode = getTypePropertyNode(secondArgNode);
     if (typePropertyNode) {
-      const typePropertyValueNode = typePropertyNode.value
+      const typePropertyValueNode = typePropertyNode.value;
       if (isStringLiteralNode(typePropertyValueNode)) {
-        const typePropertyValue = typePropertyValueNode.value
+        const typePropertyValue = typePropertyValueNode.value;
         if (typePropertyValue === "module") {
-          expectedType = "js_module"
+          expectedType = "js_module";
         }
       }
     }
   }
 
-  const firstArgNode = node.arguments[0]
+  const firstArgNode = node.arguments[0];
   if (isStringLiteralNode(firstArgNode)) {
-    const specifierNode = firstArgNode
+    const specifierNode = firstArgNode;
     onUrl({
       type: "js_url",
       subtype: referenceSubtype,
@@ -128,8 +128,8 @@ const analyzeWorkerCallArguments = (
       end: specifierNode.end,
       line: specifierNode.loc.start.line,
       column: specifierNode.loc.start.column,
-    })
-    return
+    });
+    return;
   }
   if (isNewUrlCall(firstArgNode)) {
     analyzeNewUrlCall(firstArgNode, {
@@ -139,11 +139,11 @@ const analyzeWorkerCallArguments = (
           expectedType,
           expectedSubtype,
           typePropertyNode,
-        })
-        onUrl(mention)
+        });
+        onUrl(mention);
       },
-    })
-    return
+    });
+    return;
   }
   if (isJsModule && isImportMetaResolveCall(firstArgNode)) {
     analyzeImportMetaResolveCall(firstArgNode, {
@@ -152,10 +152,10 @@ const analyzeWorkerCallArguments = (
           expectedType,
           expectedSubtype,
           typePropertyNode,
-        })
-        onUrl(mention)
+        });
+        onUrl(mention);
       },
-    })
-    return
+    });
+    return;
   }
-}
+};

package/src/js/parse_js_urls.js

@@ -1,16 +1,16 @@
-import { ancestor } from "acorn-walk"
+import { ancestor } from "acorn-walk";
 
-import { parseJsWithAcorn } from "./parse_js_with_acorn.js"
+import { parseJsWithAcorn } from "./parse_js_with_acorn.js";
 import {
   analyzeImportExpression,
   analyzeImportDeclaration,
   analyzeExportNamedDeclaration,
   analyzeExportAllDeclaration,
-} from "./js_static_analysis/import_export.js"
+} from "./js_static_analysis/import_export.js";
 import {
   isImportMetaResolveCall,
   analyzeImportMetaResolveCall,
-} from "./js_static_analysis/import_meta_resolve.js"
+} from "./js_static_analysis/import_meta_resolve.js";
 import {
   isNewWorkerCall,
   analyzeNewWorkerCall,
@@ -18,15 +18,15 @@ import {
   analyzeNewSharedWorkerCall,
   isServiceWorkerRegisterCall,
   analyzeServiceWorkerRegisterCall,
-} from "./js_static_analysis/web_worker_entry_point.js"
+} from "./js_static_analysis/web_worker_entry_point.js";
 import {
   isImportScriptsCall,
   analyzeImportScriptCalls,
-} from "./js_static_analysis/web_worker.js"
+} from "./js_static_analysis/web_worker.js";
 import {
   isNewUrlCall,
   analyzeNewUrlCall,
-} from "./js_static_analysis/new_url.js"
+} from "./js_static_analysis/new_url.js";
 import {
   isSystemRegisterCall,
   analyzeSystemRegisterCall,
@@ -34,71 +34,96 @@ import {
   analyzeSystemImportCall,
   isSystemResolveCall,
   analyzeSystemResolveCall,
-} from "./js_static_analysis/system.js"
+} from "./js_static_analysis/system.js";
+import {
+  isNewBlobCall,
+  analyzeNewBlobCall,
+} from "./js_static_analysis/new_blob.js";
+import {
+  isNewInlineContentCall,
+  analyzeNewInlineContentCall,
+} from "./js_static_analysis/new_inline_content.js";
+import {
+  isJSONParseCall,
+  analyzeJSONParseCall,
+} from "./js_static_analysis/json_parse.js";
 
 export const parseJsUrls = async ({
   js,
   url,
   isJsModule = false,
   isWebWorker = false,
+  inlineContent = true,
 } = {}) => {
-  const jsUrls = []
+  const jsUrls = [];
   const jsAst = await parseJsWithAcorn({
     js,
     url,
     isJsModule,
-  })
+  });
   const onUrl = (jsUrl) => {
-    jsUrls.push(jsUrl)
-  }
+    jsUrls.push(jsUrl);
+  };
+  const onInlineContent = (inlineContentInfo) => {
+    jsUrls.push({
+      isInline: true,
+      ...inlineContentInfo,
+    });
+  };
   ancestor(jsAst, {
     ImportDeclaration: (node) => {
-      analyzeImportDeclaration(node, { onUrl })
+      analyzeImportDeclaration(node, { onUrl });
     },
     ImportExpression: (node) => {
-      analyzeImportExpression(node, { onUrl })
+      analyzeImportExpression(node, { onUrl });
     },
     ExportNamedDeclaration: (node) => {
-      analyzeExportNamedDeclaration(node, { onUrl })
+      analyzeExportNamedDeclaration(node, { onUrl });
     },
     ExportAllDeclaration: (node) => {
-      analyzeExportAllDeclaration(node, { onUrl })
+      analyzeExportAllDeclaration(node, { onUrl });
     },
     CallExpression: (node) => {
       if (isJsModule && isImportMetaResolveCall(node)) {
-        analyzeImportMetaResolveCall(node, { onUrl })
-        return
+        analyzeImportMetaResolveCall(node, { onUrl });
+        return;
       }
       if (isServiceWorkerRegisterCall(node)) {
         analyzeServiceWorkerRegisterCall(node, {
           isJsModule,
           onUrl,
-        })
-        return
+        });
+        return;
       }
       if (isWebWorker && isImportScriptsCall(node)) {
         analyzeImportScriptCalls(node, {
           onUrl,
-        })
-        return
+        });
+        return;
       }
       if (!isJsModule && isSystemRegisterCall(node)) {
         analyzeSystemRegisterCall(node, {
           onUrl,
-        })
-        return
+        });
+        return;
       }
       if (!isJsModule && isSystemImportCall(node)) {
         analyzeSystemImportCall(node, {
           onUrl,
-        })
-        return
+        });
+        return;
       }
       if (!isJsModule && isSystemResolveCall(node)) {
         analyzeSystemResolveCall(node, {
           onUrl,
-        })
-        return
+        });
+        return;
+      }
+      if (inlineContent && isJSONParseCall(node)) {
+        analyzeJSONParseCall(node, {
+          onInlineContent,
+        });
+        return;
       }
     },
     NewExpression: (node, ancestors) => {
@@ -106,33 +131,45 @@ export const parseJsUrls = async ({
         analyzeNewWorkerCall(node, {
           isJsModule,
           onUrl,
-        })
-        return
+        });
+        return;
       }
       if (isNewSharedWorkerCall(node)) {
         analyzeNewSharedWorkerCall(node, {
           isJsModule,
           onUrl,
-        })
-        return
+        });
+        return;
       }
       if (isNewUrlCall(node)) {
-        const parent = ancestors[ancestors.length - 2]
+        const parent = ancestors[ancestors.length - 2];
         if (
           parent &&
           (isNewWorkerCall(parent) ||
             isNewSharedWorkerCall(parent) ||
             isServiceWorkerRegisterCall(parent))
         ) {
-          return
+          return;
         }
         analyzeNewUrlCall(node, {
           isJsModule,
           onUrl,
-        })
-        return
+        });
+        return;
+      }
+      if (inlineContent && isNewInlineContentCall(node)) {
+        analyzeNewInlineContentCall(node, {
+          onInlineContent,
+        });
+        return;
+      }
+      if (inlineContent && isNewBlobCall(node)) {
+        analyzeNewBlobCall(node, {
+          onInlineContent,
+        });
+        return;
       }
     },
-  })
-  return jsUrls
-}
+  });
+  return jsUrls;
+};

package/src/js/parse_js_with_acorn.js

@@ -1,10 +1,10 @@
-import { createJsParseError } from "./js_parse_error.js"
+import { createJsParseError } from "./js_parse_error.js";
 
-let AcornParser
-let _getLineInfo
+let AcornParser;
+let _getLineInfo;
 
 export const parseJsWithAcorn = async ({ js, url, isJsModule }) => {
-  await initAcornParser()
+  await initAcornParser();
   try {
     // https://github.com/acornjs/acorn/tree/master/acorn#interface
     const jsAst = AcornParser.parse(js, {
@@ -12,30 +12,30 @@ export const parseJsWithAcorn = async ({ js, url, isJsModule }) => {
       allowAwaitOutsideFunction: true,
       sourceType: isJsModule ? "module" : "script",
       ecmaVersion: 2022,
-    })
-    return jsAst
+    });
+    return jsAst;
   } catch (e) {
     if (e && e.name === "SyntaxError") {
-      const { line, column } = _getLineInfo(js, e.raisedAt)
+      const { line, column } = _getLineInfo(js, e.raisedAt);
       throw createJsParseError({
         message: e.message,
         reasonCode: e.message,
         url,
         line,
         column,
-      })
+      });
     }
-    throw e
+    throw e;
   }
-}
+};
 
 const initAcornParser = async () => {
   if (AcornParser) {
-    return
+    return;
   }
-  const { Parser, getLineInfo } = await import("acorn")
-  const { importAssertions } = await import("acorn-import-assertions")
+  const { Parser, getLineInfo } = await import("acorn");
+  const { importAssertions } = await import("acorn-import-assertions");
 
-  AcornParser = Parser.extend(importAssertions)
-  _getLineInfo = getLineInfo
-}
+  AcornParser = Parser.extend(importAssertions);
+  _getLineInfo = getLineInfo;
+};

package/src/main.js

@@ -4,41 +4,41 @@ export {
   stringifyHtmlAst,
   parseSvgString,
   stringifySvgAst,
-} from "./html/html_parse.js"
-export { visitHtmlNodes, findHtmlNode } from "./html/html_search.js"
-export { analyzeScriptNode, analyzeLinkNode } from "./html/html_analysis.js"
+} from "./html/html_parse.js";
+export { visitHtmlNodes, findHtmlNode } from "./html/html_search.js";
+export { analyzeScriptNode, analyzeLinkNode } from "./html/html_analysis.js";
 export {
   getHtmlNodeText,
   removeHtmlNodeText,
   setHtmlNodeText,
-} from "./html/html_node_text.js"
-export { parseSrcSet, stringifySrcSet } from "./html/html_src_set.js"
+} from "./html/html_node_text.js";
+export { parseSrcSet, stringifySrcSet } from "./html/html_src_set.js";
 export {
   getHtmlNodeAttribute,
   setHtmlNodeAttributes,
-} from "./html/html_node_attributes.js"
+} from "./html/html_node_attributes.js";
 export {
   removeHtmlNode,
   createHtmlNode,
   injectHtmlNode,
   injectHtmlNodeAsEarlyAsPossible,
   insertHtmlNodeAfter,
-} from "./html/html_node.js"
+} from "./html/html_node.js";
 export {
   inlineScriptNode,
   inlineLinkStylesheetNode,
   inlineImgNode,
-} from "./html/html_inlining.js"
+} from "./html/html_inlining.js";
 export {
   getHtmlNodePosition,
   getHtmlNodeAttributePosition,
-} from "./html/html_node_position.js"
+} from "./html/html_node_position.js";
 
 // css
-export { parseCssUrls } from "./css/parse_css_urls.js"
+export { parseCssUrls } from "./css/parse_css_urls.js";
 
 // js
-export { applyBabelPlugins } from "./js/apply_babel_plugins.js"
-export { injectJsImport } from "./js/babel_utils.js"
-export { parseJsWithAcorn } from "./js/parse_js_with_acorn.js"
-export { parseJsUrls } from "./js/parse_js_urls.js"
+export { applyBabelPlugins } from "./js/apply_babel_plugins.js";
+export { injectJsImport } from "./js/babel_utils.js";
+export { parseJsWithAcorn } from "./js/parse_js_with_acorn.js";
+export { parseJsUrls } from "./js/parse_js_urls.js";

package/src/require.js

@@ -1,3 +1,3 @@
-import { createRequire } from "node:module"
+import { createRequire } from "node:module";
 
-export const require = createRequire(import.meta.url)
+export const require = createRequire(import.meta.url);