@jsenv/ast 3.0.7 → 3.0.8

package/src/html/html_node_text.js

@@ -1,29 +1,29 @@
 import {
   getHtmlNodeAttribute,
   setHtmlNodeAttributes,
-} from "./html_node_attributes.js"
+} from "./html_node_attributes.js";
 
 export const getHtmlNodeText = (htmlNode) => {
-  const textNode = getTextNode(htmlNode)
-  return textNode ? textNode.value : undefined
-}
+  const textNode = getTextNode(htmlNode);
+  return textNode ? textNode.value : undefined;
+};
 
 const getTextNode = (htmlNode) => {
   if (htmlNode.nodeName === "#text") {
-    return null
+    return null;
   }
-  const firstChild = htmlNode.childNodes[0]
+  const firstChild = htmlNode.childNodes[0];
   const textNode =
-    firstChild && firstChild.nodeName === "#text" ? firstChild : null
-  return textNode
-}
+    firstChild && firstChild.nodeName === "#text" ? firstChild : null;
+  return textNode;
+};
 
 export const removeHtmlNodeText = (htmlNode) => {
-  const textNode = getTextNode(htmlNode)
+  const textNode = getTextNode(htmlNode);
   if (textNode) {
-    htmlNode.childNodes = []
+    htmlNode.childNodes = [];
   }
-}
+};
 
 export const setHtmlNodeText = (
   htmlNode,
@@ -34,85 +34,85 @@ export const setHtmlNodeText = (
     const contentIndentedAttribute = getHtmlNodeAttribute(
       htmlNode,
       "content-indented",
-    )
+    );
     if (contentIndentedAttribute === undefined) {
-      const indentation = getIndentation(htmlNode)
-      textContent = setIndentation(textContent, indentation)
+      const indentation = getIndentation(htmlNode);
+      textContent = setIndentation(textContent, indentation);
       setHtmlNodeAttributes(htmlNode, {
         "content-indented": "",
-      })
+      });
     }
   }
-  const textNode = getTextNode(htmlNode)
+  const textNode = getTextNode(htmlNode);
   if (textNode) {
-    textNode.value = textContent
+    textNode.value = textContent;
   } else {
     const newTextNode = {
       nodeName: "#text",
       value: textContent,
       parentNode: htmlNode,
-    }
-    htmlNode.childNodes.splice(0, 0, newTextNode)
+    };
+    htmlNode.childNodes.splice(0, 0, newTextNode);
   }
-}
+};
 
 export const getIndentation = (htmlNode) => {
-  const parentNode = htmlNode.parentNode
+  const parentNode = htmlNode.parentNode;
   if (!parentNode) {
-    return ""
+    return "";
   }
 
-  const siblings = parentNode.childNodes
-  const index = siblings.indexOf(htmlNode)
+  const siblings = parentNode.childNodes;
+  const index = siblings.indexOf(htmlNode);
   if (index === 0) {
     if (htmlNode.nodeName === "#text") {
-      return extractIndentation(htmlNode)
+      return extractIndentation(htmlNode);
     }
-    return ""
+    return "";
   }
 
-  let textNodeIndex = 0
-  let textNode
+  let textNodeIndex = 0;
+  let textNode;
   while (textNodeIndex !== index) {
-    const previousSibling = siblings[textNodeIndex]
-    textNodeIndex++
+    const previousSibling = siblings[textNodeIndex];
+    textNodeIndex++;
     if (previousSibling.nodeName === "#text") {
-      textNode = previousSibling
-      break
+      textNode = previousSibling;
+      break;
     }
   }
   if (!textNode) {
-    return ""
+    return "";
   }
 
-  return extractIndentation(textNode)
-}
+  return extractIndentation(textNode);
+};
 
 const extractIndentation = (textNode) => {
-  const text = textNode.value
-  const lines = text.split(/\r?\n/)
-  const lastLine = lines[lines.length - 1]
+  const text = textNode.value;
+  const lines = text.split(/\r?\n/);
+  const lastLine = lines[lines.length - 1];
   if (lastLine.match(/^[\t ]+$/)) {
-    return lastLine
+    return lastLine;
   }
-  return ""
-}
+  return "";
+};
 
 const setIndentation = (htmlNodeText, indentation) => {
-  const contentIdentation = increaseIndentation(indentation, 2)
-  const lines = htmlNodeText.trimEnd().split(/\r?\n/)
-  let result = `\n`
-  let i = 0
+  const contentIdentation = increaseIndentation(indentation, 2);
+  const lines = htmlNodeText.trimEnd().split(/\r?\n/);
+  let result = `\n`;
+  let i = 0;
   while (i < lines.length) {
-    const line = lines[i]
-    i++
-    result += `${contentIdentation}${line}\n`
+    const line = lines[i];
+    i++;
+    result += `${contentIdentation}${line}\n`;
   }
-  result += `${indentation}`
-  return result
-}
+  result += `${indentation}`;
+  return result;
+};
 
 export const increaseIndentation = (indentation, size) => {
-  const char = indentation[0]
-  return char ? `${indentation}${char.repeat(size)}` : " ".repeat(size)
-}
+  const char = indentation[0];
+  return char ? `${indentation}${char.repeat(size)}` : " ".repeat(size);
+};

package/src/html/html_parse.js

@@ -1,63 +1,63 @@
-import { parse, serialize, parseFragment } from "parse5"
+import { parse, serialize, parseFragment } from "parse5";
 
-import { insertHtmlNodeAfter, insertHtmlNodeBefore } from "./html_node.js"
+import { insertHtmlNodeAfter, insertHtmlNodeBefore } from "./html_node.js";
 import {
   getHtmlNodeAttribute,
   setHtmlNodeAttributes,
-} from "./html_node_attributes.js"
+} from "./html_node_attributes.js";
 import {
   storeHtmlNodePosition,
   storeHtmlNodeAttributePosition,
-} from "./html_node_position.js"
-import { findHtmlChildNode, visitHtmlNodes } from "./html_search.js"
-import { getHtmlNodeText } from "./html_node_text.js"
+} from "./html_node_position.js";
+import { findHtmlChildNode, visitHtmlNodes } from "./html_search.js";
+import { getHtmlNodeText } from "./html_node_text.js";
 
 export const parseHtmlString = (
   htmlString,
   { storeOriginalPositions = true } = {},
 ) => {
-  const htmlAst = parse(htmlString, { sourceCodeLocationInfo: true })
+  const htmlAst = parse(htmlString, { sourceCodeLocationInfo: true });
   if (storeOriginalPositions) {
     const htmlNode = findHtmlChildNode(
       htmlAst,
       (node) => node.nodeName === "html",
-    )
-    const stored = getHtmlNodeAttribute(htmlNode, "original-position-stored")
+    );
+    const stored = getHtmlNodeAttribute(htmlNode, "original-position-stored");
     if (stored === undefined) {
       visitHtmlNodes(htmlAst, {
         "*": (node) => {
           if (node.nodeName === "script" || node.nodeName === "style") {
-            const htmlNodeText = getHtmlNodeText(node)
+            const htmlNodeText = getHtmlNodeText(node);
             if (htmlNodeText !== undefined) {
-              storeHtmlNodePosition(node)
+              storeHtmlNodePosition(node);
             }
           }
-          storeHtmlNodeAttributePosition(node, "src")
-          storeHtmlNodeAttributePosition(node, "href")
+          storeHtmlNodeAttributePosition(node, "src");
+          storeHtmlNodeAttributePosition(node, "href");
         },
-      })
+      });
       setHtmlNodeAttributes(htmlNode, {
         "original-position-stored": "",
-      })
+      });
     }
   }
-  const htmlNode = htmlAst.childNodes.find((node) => node.nodeName === "html")
+  const htmlNode = htmlAst.childNodes.find((node) => node.nodeName === "html");
   if (htmlNode) {
     const bodyNode = htmlNode.childNodes.find(
       (node) => node.nodeName === "body",
-    )
+    );
     // for some reason "parse5" adds "\n\n" to the last text node of <body>
-    const lastBodyNode = bodyNode.childNodes[bodyNode.childNodes.length - 1]
+    const lastBodyNode = bodyNode.childNodes[bodyNode.childNodes.length - 1];
     if (
       lastBodyNode &&
       lastBodyNode.nodeName === "#text" &&
       lastBodyNode.value.endsWith("\n\n")
     ) {
-      lastBodyNode.value = lastBodyNode.value.slice(0, -2)
+      lastBodyNode.value = lastBodyNode.value.slice(0, -2);
     }
   }
-  return htmlAst
-}
+  return htmlAst;
+};
 
 export const stringifyHtmlAst = (
   htmlAst,
@@ -67,15 +67,15 @@ export const stringifyHtmlAst = (
     const htmlNode = findHtmlChildNode(
       htmlAst,
       (node) => node.nodeName === "html",
-    )
+    );
     const storedAttribute = getHtmlNodeAttribute(
       htmlNode,
       "original-position-stored",
-    )
+    );
     if (storedAttribute !== undefined) {
       setHtmlNodeAttributes(htmlNode, {
         "original-position-stored": undefined,
-      })
+      });
       visitHtmlNodes(htmlAst, {
         "*": (node) => {
           setHtmlNodeAttributes(node, {
@@ -93,70 +93,73 @@ export const stringifyHtmlAst = (
                   "content-indented": undefined,
                 }
               : {}),
-          })
+          });
         },
-      })
+      });
     }
   }
   // ensure body and html have \n
-  ensureLineBreaksBetweenHtmlNodes(htmlAst)
-  const htmlString = serialize(htmlAst)
-  return htmlString
-}
+  ensureLineBreaksBetweenHtmlNodes(htmlAst);
+  const htmlString = serialize(htmlAst);
+  return htmlString;
+};
 
 const ensureLineBreaksBetweenHtmlNodes = (rootNode) => {
-  const mutations = []
+  const mutations = [];
 
-  const documentType = rootNode.childNodes[0]
+  const documentType = rootNode.childNodes[0];
   if (documentType.nodeName === "#documentType") {
-    const html = rootNode.childNodes[1]
+    const html = rootNode.childNodes[1];
     if (html.nodeName === "html") {
       mutations.push(() => {
-        insertHtmlNodeAfter({ nodeName: "#text", value: "\n" }, documentType)
-      })
+        insertHtmlNodeAfter({ nodeName: "#text", value: "\n" }, documentType);
+      });
 
-      const head = html.childNodes[0]
+      const head = html.childNodes[0];
       if (head.nodeName === "head") {
         mutations.push(() => {
-          insertHtmlNodeBefore({ nodeName: "#text", value: "\n  " }, head)
-        })
+          insertHtmlNodeBefore({ nodeName: "#text", value: "\n  " }, head);
+        });
       }
 
-      const body = html.childNodes.find((node) => node.nodeName === "body")
+      const body = html.childNodes.find((node) => node.nodeName === "body");
       if (body) {
-        const bodyLastChild = body.childNodes[body.childNodes.length - 1]
+        const bodyLastChild = body.childNodes[body.childNodes.length - 1];
         if (bodyLastChild.nodeName !== "#text") {
           mutations.push(() => {
             insertHtmlNodeAfter(
               { nodeName: "#text", value: "\n  " },
               bodyLastChild,
-            )
-          })
+            );
+          });
         }
         if (
           bodyLastChild.nodeName === "#text" &&
           bodyLastChild.value[bodyLastChild.value.length - 1] === "\n"
         ) {
-          bodyLastChild.value = bodyLastChild.value.slice(0, -1)
+          bodyLastChild.value = bodyLastChild.value.slice(0, -1);
         }
       }
 
-      const htmlLastChild = html.childNodes[html.childNodes.length - 1]
+      const htmlLastChild = html.childNodes[html.childNodes.length - 1];
       if (htmlLastChild.nodeName !== "#text") {
         mutations.push(() => {
-          insertHtmlNodeAfter({ nodeName: "#text", value: "\n" }, htmlLastChild)
-        })
+          insertHtmlNodeAfter(
+            { nodeName: "#text", value: "\n" },
+            htmlLastChild,
+          );
+        });
       }
     }
   }
 
-  mutations.forEach((m) => m())
-}
+  mutations.forEach((m) => m());
+};
 
 export const parseSvgString = (svgString) => {
   const svgAst = parseFragment(svgString, {
     sourceCodeLocationInfo: true,
-  })
-  return svgAst
-}
-export const stringifySvgAst = stringifyHtmlAst
+  });
+  return svgAst;
+};
+export const stringifySvgAst = stringifyHtmlAst;

package/src/html/html_search.js

@@ -1,64 +1,64 @@
-import { getHtmlNodeAttribute } from "./html_node_attributes.js"
+import { getHtmlNodeAttribute } from "./html_node_attributes.js";
 
 export const visitHtmlNodes = (htmlAst, visitors) => {
   const visitNode = (node) => {
-    const visitor = visitors[node.nodeName] || visitors["*"]
+    const visitor = visitors[node.nodeName] || visitors["*"];
     if (visitor) {
-      const callbackReturnValue = visitor(node)
+      const callbackReturnValue = visitor(node);
       if (callbackReturnValue === "stop") {
-        return
+        return;
       }
     }
-    const { childNodes } = node
+    const { childNodes } = node;
     if (childNodes) {
-      let i = 0
+      let i = 0;
       while (i < childNodes.length) {
-        visitNode(childNodes[i++])
+        visitNode(childNodes[i++]);
       }
     }
-  }
-  visitNode(htmlAst)
-}
+  };
+  visitNode(htmlAst);
+};
 
 export const findHtmlNode = (htmlAst, predicate) => {
-  let nodeMatching = null
+  let nodeMatching = null;
   visitHtmlNodes(htmlAst, {
     "*": (node) => {
       if (predicate(node)) {
-        nodeMatching = node
-        return "stop"
+        nodeMatching = node;
+        return "stop";
       }
-      return null
+      return null;
     },
-  })
-  return nodeMatching
-}
+  });
+  return nodeMatching;
+};
 
 export const findHtmlChildNode = (htmlNode, predicate) => {
-  const { childNodes = [] } = htmlNode
-  return childNodes.find(predicate)
-}
+  const { childNodes = [] } = htmlNode;
+  return childNodes.find(predicate);
+};
 
 export const findHtmlNodes = (htmlAst, predicate) => {
-  const nodes = []
+  const nodes = [];
   visitHtmlNodes(htmlAst, {
     "*": (node) => {
       if (predicate(node)) {
-        nodes.push(node)
+        nodes.push(node);
       }
-      return null
+      return null;
     },
-  })
-  return nodes
-}
+  });
+  return nodes;
+};
 
 export const findHtmlNodeByTagName = (htmlAst, tagName) => {
-  return findHtmlNode(htmlAst, (node) => node.nodeName === tagName)
-}
+  return findHtmlNode(htmlAst, (node) => node.nodeName === tagName);
+};
 
 export const findHtmlNodeById = (htmlAst, id) => {
   return findHtmlNode(htmlAst, (node) => {
-    const idCandidate = getHtmlNodeAttribute(node, "id")
-    return idCandidate === id
-  })
-}
+    const idCandidate = getHtmlNodeAttribute(node, "id");
+    return idCandidate === id;
+  });
+};

package/src/html/html_src_set.js

@@ -1,18 +1,18 @@
 export const parseSrcSet = (srcset) => {
-  const srcCandidates = []
+  const srcCandidates = [];
   srcset.split(",").forEach((set) => {
-    const [specifier, descriptor] = set.trim().split(" ")
+    const [specifier, descriptor] = set.trim().split(" ");
     srcCandidates.push({
       specifier,
       descriptor,
-    })
-  })
-  return srcCandidates
-}
+    });
+  });
+  return srcCandidates;
+};
 
 export const stringifySrcSet = (srcCandidates) => {
   const srcset = srcCandidates
     .map(({ specifier, descriptor }) => `${specifier} ${descriptor}`)
-    .join(", ")
-  return srcset
-}
+    .join(", ");
+  return srcset;
+};

package/src/js/apply_babel_plugins.js

@@ -3,9 +3,9 @@
  * - https://astexplorer.net/
  * - https://bvaughn.github.io/babel-repl
  */
-import { fileURLToPath } from "node:url"
+import { fileURLToPath } from "node:url";
 
-import { createJsParseError } from "./js_parse_error.js"
+import { createJsParseError } from "./js_parse_error.js";
 
 export const applyBabelPlugins = async ({
   babelPlugins,
@@ -17,18 +17,18 @@ export const applyBabelPlugins = async ({
     [urlInfo.type]: undefined,
     js_module: "module",
     js_classic: "classic",
-  }[urlInfo.type]
-  const url = urlInfo.originalUrl
-  const generatedUrl = urlInfo.generatedUrl
-  const content = urlInfo.content
+  }[urlInfo.type];
+  const url = urlInfo.originalUrl;
+  const generatedUrl = urlInfo.generatedUrl;
+  const content = urlInfo.content;
 
   if (babelPlugins.length === 0) {
-    return { code: content }
+    return { code: content };
   }
-  const { transformAsync, transformFromAstAsync } = await import("@babel/core")
+  const { transformAsync, transformFromAstAsync } = await import("@babel/core");
   const sourceFileName = url.startsWith("file:")
     ? fileURLToPath(url)
-    : undefined
+    : undefined;
   options = {
     ast: false,
     // https://babeljs.io/docs/en/options#source-map-options
@@ -67,14 +67,14 @@ export const applyBabelPlugins = async ({
     },
     plugins: babelPlugins,
     ...options,
-  }
+  };
   try {
     if (ast) {
-      const result = await transformFromAstAsync(ast, content, options)
-      return result
+      const result = await transformFromAstAsync(ast, content, options);
+      return result;
     }
-    const result = await transformAsync(content, options)
-    return result
+    const result = await transformAsync(content, options);
+    return result;
   } catch (error) {
     if (error && error.code === "BABEL_PARSE_ERROR") {
       throw createJsParseError({
@@ -84,16 +84,16 @@ export const applyBabelPlugins = async ({
         url,
         line: error.loc.line,
         column: error.loc.column,
-      })
+      });
     }
-    throw error
+    throw error;
   }
-}
+};
 
 const useTypeScriptExtension = (url) => {
-  const { pathname } = new URL(url)
-  return pathname.endsWith(".ts") || pathname.endsWith(".tsx")
-}
+  const { pathname } = new URL(url);
+  return pathname.endsWith(".ts") || pathname.endsWith(".tsx");
+};
 
 // const pattern = [
 //   "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",

package/src/js/babel_utils.js

@@ -1,4 +1,4 @@
-import { require } from "../require.js"
+import { require } from "../require.js";
 
 // https://github.com/babel/babel/tree/master/packages/babel-helper-module-imports
 export const injectJsImport = ({
@@ -14,30 +14,30 @@ export const injectJsImport = ({
     addDefault,
     addNamed,
     addSideEffect,
-  } = require("@babel/helper-module-imports")
+  } = require("@babel/helper-module-imports");
 
   if (namespace) {
     return addNamespace(programPath, from, {
       nameHint,
-    })
+    });
   }
   if (name) {
-    return addNamed(programPath, name, from)
+    return addNamed(programPath, name, from);
   }
   if (sideEffect) {
-    return addSideEffect(programPath, from)
+    return addSideEffect(programPath, from);
   }
   return addDefault(programPath, from, {
     nameHint,
-  })
-}
+  });
+};
 
 const generateExpressionAst = (expression, options) => {
-  const { parseExpression } = require("@babel/parser")
+  const { parseExpression } = require("@babel/parser");
 
-  const ast = parseExpression(expression, options)
-  return ast
-}
+  const ast = parseExpression(expression, options);
+  return ast;
+};
 
 export const generateValueAst = (value) => {
   const valueAst = generateExpressionAst(
@@ -46,19 +46,19 @@ export const generateValueAst = (value) => {
       : value === null
       ? "null"
       : JSON.stringify(value),
-  )
-  return valueAst
-}
+  );
+  return valueAst;
+};
 
 export const injectAstAfterImport = (programPath, ast) => {
-  const bodyNodePaths = programPath.get("body")
+  const bodyNodePaths = programPath.get("body");
   const notAnImportIndex = bodyNodePaths.findIndex(
     (bodyNodePath) => bodyNodePath.node.type !== "ImportDeclaration",
-  )
-  const notAnImportNodePath = bodyNodePaths[notAnImportIndex]
+  );
+  const notAnImportNodePath = bodyNodePaths[notAnImportIndex];
   if (notAnImportNodePath) {
-    notAnImportNodePath.insertBefore(ast)
+    notAnImportNodePath.insertBefore(ast);
   } else {
-    bodyNodePaths[0].insertBefore(ast)
+    bodyNodePaths[0].insertBefore(ast);
   }
-}
+};

package/src/js/js_parse_error.js

@@ -5,11 +5,11 @@ export const createJsParseError = ({
   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;
+};