@jsenv/ast 3.0.7 → 3.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/ast",
-  "version": "3.0.7",
+  "version": "3.0.8",
   "description": "Parse and transform HTML,CSS and JS",
   "license": "MIT",
   "repository": {

package/src/css/apply_post_css.js

@@ -1,6 +1,6 @@
-import { fileURLToPath } from "node:url"
+import { fileURLToPath } from "node:url";
 
-import { createCssParseError } from "./css_parse_error.js"
+import { createCssParseError } from "./css_parse_error.js";
 
 export const applyPostCss = async ({
   sourcemaps = "comment",
@@ -11,10 +11,10 @@ export const applyPostCss = async ({
   map,
   content,
 }) => {
-  const { default: postcss } = await import("postcss")
+  const { default: postcss } = await import("postcss");
 
   try {
-    const cssFileUrl = urlToFileUrl(url)
+    const cssFileUrl = urlToFileUrl(url);
     const result = await postcss(plugins).process(content, {
       collectUrls: true,
       from: fileURLToPath(cssFileUrl),
@@ -26,12 +26,12 @@ export const applyPostCss = async ({
         ...(map ? { prev: JSON.stringify(map) } : {}),
       },
       ...options,
-    })
+    });
     return {
       postCssMessages: result.messages,
       map: result.map.toJSON(),
       content: result.css,
-    }
+    };
   } catch (error) {
     if (error.name === "CssSyntaxError") {
       throw createCssParseError({
@@ -40,11 +40,11 @@ export const applyPostCss = async ({
         url,
         line: error.line,
         column: error.column,
-      })
+      });
     }
-    throw error
+    throw error;
   }
-}
+};
 
 // the goal of this function is to take an url that is likely an http url
 // info a file:// url
@@ -52,13 +52,13 @@ export const applyPostCss = async ({
 // must becomes file:///dir/file.js
 // but in windows it must be file://C:/dir/file.js
 const filesystemRootUrl =
-  process.platform === "win32" ? `file:///${process.cwd()[0]}:/` : "file:///"
+  process.platform === "win32" ? `file:///${process.cwd()[0]}:/` : "file:///";
 const urlToFileUrl = (url) => {
-  const urlString = String(url)
+  const urlString = String(url);
   if (urlString.startsWith("file:")) {
-    return urlString
+    return urlString;
   }
-  const origin = new URL(url).origin
-  const afterOrigin = urlString.slice(origin.length)
-  return new URL(afterOrigin, filesystemRootUrl).href
-}
+  const origin = new URL(url).origin;
+  const afterOrigin = urlString.slice(origin.length);
+  return new URL(afterOrigin, filesystemRootUrl).href;
+};

package/src/css/css_parse_error.js

@@ -5,11 +5,11 @@ export const createCssParseError = ({
   line,
   column,
 }) => {
-  const parseError = new Error(message)
-  parseError.reasonCode = reasonCode
-  parseError.code = "PARSE_ERROR"
-  parseError.url = url
-  parseError.line = line
-  parseError.column = column
-  return parseError
-}
+  const parseError = new Error(message);
+  parseError.reasonCode = reasonCode;
+  parseError.code = "PARSE_ERROR";
+  parseError.url = url;
+  parseError.line = line;
+  parseError.column = column;
+  return parseError;
+};

package/src/css/parse_css_urls.js

@@ -1,8 +1,8 @@
-import { applyPostCss } from "./apply_post_css.js"
-import { postCssPluginUrlVisitor } from "./postcss_plugin_url_visitor.js"
+import { applyPostCss } from "./apply_post_css.js";
+import { postCssPluginUrlVisitor } from "./postcss_plugin_url_visitor.js";
 
 export const parseCssUrls = async ({ css, url }) => {
-  const cssUrls = []
+  const cssUrls = [];
   await applyPostCss({
     content: css,
     url,
@@ -24,10 +24,10 @@ export const parseCssUrls = async ({ css, url }) => {
             end: specifierEnd,
             line: specifierLine,
             column: specifierColumn,
-          })
+          });
         },
       }),
     ],
-  })
-  return cssUrls
-}
+  });
+  return cssUrls;
+};

package/src/css/postcss_plugin_url_visitor.js

@@ -11,37 +11,37 @@ hence sourcemap cannot point the original source location
 
 */
 
-import { pathToFileURL } from "node:url"
-import { createRequire } from "node:module"
+import { pathToFileURL } from "node:url";
+import { createRequire } from "node:module";
 
-const require = createRequire(import.meta.url)
+const require = createRequire(import.meta.url);
 
 export const postCssPluginUrlVisitor = ({ urlVisitor = () => null }) => {
-  const parseCssValue = require("postcss-value-parser")
-  const stringifyCssNodes = parseCssValue.stringify
+  const parseCssValue = require("postcss-value-parser");
+  const stringifyCssNodes = parseCssValue.stringify;
 
   return {
     postcssPlugin: "url_visitor",
     prepare: (result) => {
-      const { from } = result.opts
-      const fromUrl = String(pathToFileURL(from))
-      const mutations = []
+      const { from } = result.opts;
+      const fromUrl = String(pathToFileURL(from));
+      const mutations = [];
       return {
         AtRule: {
           import: (atImportNode, { AtRule }) => {
             if (atImportNode.parent.type !== "root") {
-              atImportNode.warn(result, "`@import` should be top level")
-              return
+              atImportNode.warn(result, "`@import` should be top level");
+              return;
             }
             if (atImportNode.nodes) {
               atImportNode.warn(
                 result,
                 "`@import` was not terminated correctly",
-              )
-              return
+              );
+              return;
             }
-            const parsed = parseCssValue(atImportNode.params)
-            let [urlNode] = parsed.nodes
+            const parsed = parseCssValue(atImportNode.params);
+            let [urlNode] = parsed.nodes;
             if (
               !urlNode ||
               (urlNode.type !== "string" && urlNode.type !== "function")
@@ -49,62 +49,63 @@ export const postCssPluginUrlVisitor = ({ urlVisitor = () => null }) => {
               atImportNode.warn(
                 result,
                 `No URL in \`${atImportNode.toString()}\``,
-              )
-              return
+              );
+              return;
             }
-            let url = ""
+            let url = "";
             if (urlNode.type === "string") {
-              url = urlNode.value
+              url = urlNode.value;
             } else if (urlNode.type === "function") {
               // Invalid function
               if (!/^url$/i.test(urlNode.value)) {
                 atImportNode.warn(
                   result,
                   `Invalid \`url\` function in \`${atImportNode.toString()}\``,
-                )
-                return
+                );
+                return;
               }
-              const firstNode = urlNode.nodes[0]
+              const firstNode = urlNode.nodes[0];
               if (firstNode && firstNode.type === "string") {
-                urlNode = firstNode
-                url = urlNode.value
+                urlNode = firstNode;
+                url = urlNode.value;
               } else {
-                urlNode = urlNode.nodes
-                url = stringifyCssNodes(urlNode.nodes)
+                urlNode = urlNode.nodes;
+                url = stringifyCssNodes(urlNode.nodes);
               }
             }
 
-            url = url.trim()
+            url = url.trim();
             if (url.length === 0) {
               atImportNode.warn(
                 result,
                 `Empty URL in \`${atImportNode.toString()}\``,
-              )
-              return
+              );
+              return;
             }
 
-            const specifier = url
-            url = new URL(specifier, fromUrl).href
+            const specifier = url;
+            url = new URL(specifier, fromUrl).href;
             if (url === fromUrl) {
               atImportNode.warn(
                 result,
                 `\`@import\` loop in \`${atImportNode.toString()}\``,
-              )
-              return
+              );
+              return;
             }
 
-            const atRuleStart = atImportNode.source.start.offset
-            const atRuleEnd = atImportNode.source.end.offset + 1 // for the ";"
+            const atRuleStart = atImportNode.source.start.offset;
+            const atRuleEnd = atImportNode.source.end.offset + 1; // for the ";"
             const atRuleRaw = atImportNode.source.input.css.slice(
               atRuleStart,
               atRuleEnd,
-            )
-            const specifierIndex = atRuleRaw.indexOf(atImportNode.params)
-            const specifierStart = atRuleStart + specifierIndex
-            const specifierEnd = specifierStart + parsed.nodes[0].sourceEndIndex
-            const specifierLine = atImportNode.source.start.line
+            );
+            const specifierIndex = atRuleRaw.indexOf(atImportNode.params);
+            const specifierStart = atRuleStart + specifierIndex;
+            const specifierEnd =
+              specifierStart + parsed.nodes[0].sourceEndIndex;
+            const specifierLine = atImportNode.source.start.line;
             const specifierColumn =
-              atImportNode.source.start.column + specifierIndex
+              atImportNode.source.start.column + specifierIndex;
             urlVisitor({
               declarationNode: atImportNode,
               type: "@import",
@@ -117,23 +118,23 @@ export const postCssPluginUrlVisitor = ({ urlVisitor = () => null }) => {
               specifierEnd,
               replace: (newUrlSpecifier) => {
                 if (newUrlSpecifier === urlNode.value) {
-                  return
+                  return;
                 }
-                urlNode.value = newUrlSpecifier
-                const newParams = parsed.toString()
+                urlNode.value = newUrlSpecifier;
+                const newParams = parsed.toString();
                 const newAtImportRule = new AtRule({
                   name: "import",
                   params: newParams,
                   source: atImportNode.source,
-                })
-                atImportNode.replaceWith(newAtImportRule)
+                });
+                atImportNode.replaceWith(newAtImportRule);
               },
-            })
+            });
           },
         },
         Declaration: (declarationNode) => {
-          const parsed = parseCssValue(declarationNode.value)
-          const urlMutations = []
+          const parsed = parseCssValue(declarationNode.value);
+          const urlMutations = [];
           walkUrls(parsed, {
             stringifyCssNodes,
             visitor: ({ url, urlNode }) => {
@@ -142,37 +143,37 @@ export const postCssPluginUrlVisitor = ({ urlVisitor = () => null }) => {
                 declarationNode.warn(
                   result,
                   `Empty URL in \`${declarationNode.toString()}\``,
-                )
-                return
+                );
+                return;
               }
               // Skip Data URI
               if (isDataUrl(url)) {
-                return
+                return;
               }
-              const specifier = url
-              url = new URL(specifier, pathToFileURL(from))
+              const specifier = url;
+              url = new URL(specifier, pathToFileURL(from));
 
-              const declarationNodeStart = declarationNode.source.start.offset
+              const declarationNodeStart = declarationNode.source.start.offset;
               const afterDeclarationNode =
-                declarationNode.source.input.css.slice(declarationNodeStart)
+                declarationNode.source.input.css.slice(declarationNodeStart);
               const valueIndex = afterDeclarationNode.indexOf(
                 declarationNode.value,
-              )
-              const valueStart = declarationNodeStart + valueIndex
-              const specifierStart = valueStart + urlNode.sourceIndex
+              );
+              const valueStart = declarationNodeStart + valueIndex;
+              const specifierStart = valueStart + urlNode.sourceIndex;
               const specifierEnd =
                 specifierStart +
                 (urlNode.type === "word"
                   ? urlNode.value.length
-                  : urlNode.value.length + 2) // the quotes
+                  : urlNode.value.length + 2); // the quotes
               // value raw
               // declarationNode.source.input.css.slice(valueStart)
               // specifier raw
               // declarationNode.source.input.css.slice(specifierStart, specifierEnd)
-              const specifierLine = declarationNode.source.start.line
+              const specifierLine = declarationNode.source.start.line;
               const specifierColumn =
                 declarationNode.source.start.column +
-                (specifierStart - declarationNodeStart)
+                (specifierStart - declarationNodeStart);
 
               urlVisitor({
                 declarationNode,
@@ -186,61 +187,61 @@ export const postCssPluginUrlVisitor = ({ urlVisitor = () => null }) => {
                   urlMutations.push(() => {
                     // the specifier desires to be inside double quotes
                     if (newUrlSpecifier[0] === `"`) {
-                      urlNode.type = "word"
-                      urlNode.value = newUrlSpecifier
-                      return
+                      urlNode.type = "word";
+                      urlNode.value = newUrlSpecifier;
+                      return;
                     }
                     // the specifier desires to be inside simple quotes
                     if (newUrlSpecifier[0] === `'`) {
-                      urlNode.type = "word"
-                      urlNode.value = newUrlSpecifier
-                      return
+                      urlNode.type = "word";
+                      urlNode.value = newUrlSpecifier;
+                      return;
                     }
                     // the specifier desired to be just a word
                     // for the "word" type so that newUrlSpecifier can opt-out of being between quotes
                     // useful to inject __v__ calls for css inside js
-                    urlNode.type = "word"
-                    urlNode.value = newUrlSpecifier
-                  })
+                    urlNode.type = "word";
+                    urlNode.value = newUrlSpecifier;
+                  });
                 },
-              })
+              });
             },
-          })
+          });
           if (urlMutations.length) {
             mutations.push(() => {
               urlMutations.forEach((urlMutation) => {
-                urlMutation()
-              })
-              declarationNode.value = parsed.toString()
-            })
+                urlMutation();
+              });
+              declarationNode.value = parsed.toString();
+            });
           }
         },
         OnceExit: () => {
           mutations.forEach((mutation) => {
-            mutation()
-          })
+            mutation();
+          });
         },
-      }
+      };
     },
-  }
-}
-postCssPluginUrlVisitor.postcss = true
+  };
+};
+postCssPluginUrlVisitor.postcss = true;
 
 const walkUrls = (parsed, { stringifyCssNodes, visitor }) => {
   parsed.walk((node) => {
     // https://github.com/andyjansson/postcss-functions
     if (isUrlFunctionNode(node)) {
-      const { nodes } = node
-      const [urlNode] = nodes
+      const { nodes } = node;
+      const [urlNode] = nodes;
       const url =
         urlNode && urlNode.type === "string"
           ? urlNode.value
-          : stringifyCssNodes(nodes)
+          : stringifyCssNodes(nodes);
       visitor({
         url: url.trim(),
         urlNode,
-      })
-      return
+      });
+      return;
     }
 
     if (isImageSetFunctionNode(node)) {
@@ -249,40 +250,40 @@ const walkUrls = (parsed, { stringifyCssNodes, visitor }) => {
           visitor({
             url: childNode.value.trim(),
             urlNode: childNode,
-          })
-          return
+          });
+          return;
         }
 
         if (isUrlFunctionNode(node)) {
-          const { nodes } = childNode
-          const [urlNode] = nodes
+          const { nodes } = childNode;
+          const [urlNode] = nodes;
           const url =
             urlNode && urlNode.type === "string"
               ? urlNode.value
-              : stringifyCssNodes(nodes)
+              : stringifyCssNodes(nodes);
           visitor({
             url: url.trim(),
             urlNode,
-          })
-          return
+          });
+          return;
         }
-      })
+      });
     }
-  })
-}
+  });
+};
 
 const isUrlFunctionNode = (node) => {
-  return node.type === "function" && /^url$/i.test(node.value)
-}
+  return node.type === "function" && /^url$/i.test(node.value);
+};
 
 const isImageSetFunctionNode = (node) => {
   return (
     node.type === "function" && /^(?:-webkit-)?image-set$/i.test(node.value)
-  )
-}
+  );
+};
 
 const isDataUrl = (url) => {
   return /data:[^\n\r;]+?(?:;charset=[^\n\r;]+?)?;base64,([\d+/A-Za-z]+={0,2})/.test(
     url,
-  )
-}
+  );
+};

package/src/html/html_analysis.js

@@ -1,24 +1,24 @@
-import { getHtmlNodeAttribute } from "./html_node_attributes.js"
+import { getHtmlNodeAttribute } from "./html_node_attributes.js";
 
 export const analyzeScriptNode = (scriptNode) => {
-  const typeAttribute = getHtmlNodeAttribute(scriptNode, "type")
+  const typeAttribute = getHtmlNodeAttribute(scriptNode, "type");
   if (typeAttribute === undefined || typeAttribute === "text/javascript") {
     return {
       type: "js_classic",
       contentType: "text/javascript",
-    }
+    };
   }
   if (typeAttribute === "module") {
     return {
       type: "js_module",
       contentType: "text/javascript",
-    }
+    };
   }
   if (typeAttribute === "importmap") {
     return {
       type: "importmap",
       contentType: "application/importmap+json",
-    }
+    };
   }
   // jsx
   if (typeAttribute === "text/jsx") {
@@ -26,14 +26,14 @@ export const analyzeScriptNode = (scriptNode) => {
       type: "js_classic",
       contentType: "text/javascript",
       extension: ".jsx",
-    }
+    };
   }
   if (typeAttribute === "module/jsx") {
     return {
       type: "js_module",
       contentType: "text/javascript",
       extension: ".jsx",
-    }
+    };
   }
   // typescript
   if (typeAttribute === "text/ts") {
@@ -41,14 +41,14 @@ export const analyzeScriptNode = (scriptNode) => {
       type: "js_classic",
       contentType: "text/javascript",
       extension: ".ts",
-    }
+    };
   }
   if (typeAttribute === "module/ts") {
     return {
       type: "js_module",
       contentType: "text/javascript",
       extension: ".ts",
-    }
+    };
   }
   // typescript and jsx
   if (typeAttribute === "text/tsx") {
@@ -56,14 +56,14 @@ export const analyzeScriptNode = (scriptNode) => {
       type: "js_classic",
       contentType: "text/javascript",
       extension: ".tsx",
-    }
+    };
   }
   if (typeAttribute === "module/tsx") {
     return {
       type: "js_module",
       contentType: "text/javascript",
       extension: ".tsx",
-    }
+    };
   }
   // from MDN about [type] attribute:
   // "Any other value: The embedded content is treated as a data block
@@ -74,15 +74,15 @@ export const analyzeScriptNode = (scriptNode) => {
   return {
     type: "text",
     contentType: "text/plain",
-  }
-}
+  };
+};
 
 export const analyzeLinkNode = (linkNode) => {
-  const rel = getHtmlNodeAttribute(linkNode, "rel")
+  const rel = getHtmlNodeAttribute(linkNode, "rel");
   if (rel === "stylesheet") {
     return {
       isStylesheet: true,
-    }
+    };
   }
   const isResourceHint = [
     "preconnect",
@@ -90,9 +90,9 @@ export const analyzeLinkNode = (linkNode) => {
     "prefetch",
     "preload",
     "modulepreload",
-  ].includes(rel)
+  ].includes(rel);
   return {
     isResourceHint,
     rel,
-  }
-}
+  };
+};

package/src/html/html_inlining.js

@@ -1,22 +1,22 @@
 import {
   getHtmlNodeAttribute,
   setHtmlNodeAttributes,
-} from "./html_node_attributes.js"
-import { setHtmlNodeText } from "./html_node_text.js"
+} from "./html_node_attributes.js";
+import { setHtmlNodeText } from "./html_node_text.js";
 
 export const inlineScriptNode = (script, textContent) => {
-  const src = getHtmlNodeAttribute(script, "src")
+  const src = getHtmlNodeAttribute(script, "src");
   setHtmlNodeAttributes(script, {
     "inlined-from-src": src,
     "src": undefined,
     "crossorigin": undefined,
     "integrity": undefined,
-  })
-  setHtmlNodeText(script, textContent)
-}
+  });
+  setHtmlNodeText(script, textContent);
+};
 
 export const inlineLinkStylesheetNode = (link, textContent) => {
-  const href = getHtmlNodeAttribute(link, "href")
+  const href = getHtmlNodeAttribute(link, "href");
   setHtmlNodeAttributes(link, {
     "inlined-from-href": href,
     "href": undefined,
@@ -25,16 +25,16 @@ export const inlineLinkStylesheetNode = (link, textContent) => {
     "as": undefined,
     "crossorigin": undefined,
     "integrity": undefined,
-  })
-  link.nodeName = "style"
-  link.tagName = "style"
-  setHtmlNodeText(link, textContent)
-}
+  });
+  link.nodeName = "style";
+  link.tagName = "style";
+  setHtmlNodeText(link, textContent);
+};
 
 export const inlineImgNode = (img, contentAsBase64) => {
-  const src = getHtmlNodeAttribute(img, "src")
+  const src = getHtmlNodeAttribute(img, "src");
   setHtmlNodeAttributes(img, {
     "inlined-from-src": src,
     "src": contentAsBase64,
-  })
-}
+  });
+};