@appthreat/atom-parsetools 1.0.13 → 1.0.16

package/astgen.js

@@ -4,6 +4,7 @@ import { join, dirname } from "path";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { parse } from "@babel/parser";
+import { parse as parseHermes } from "hermes-parser";
 import tsc from "typescript";
 import {
   readFileSync,
@@ -39,6 +40,28 @@ const babelParserOptions = {
   ]
 };
 
+const babelFlowParserOptions = {
+  sourceType: "unambiguous",
+  allowImportExportEverywhere: true,
+  allowAwaitOutsideFunction: true,
+  allowNewTargetOutsideFunction: true,
+  allowReturnOutsideFunction: true,
+  allowSuperOutsideMethod: true,
+  allowUndeclaredExports: true,
+  errorRecovery: true,
+  plugins: [
+    "optionalChaining",
+    "classProperties",
+    "decorators-legacy",
+    "exportDefaultFrom",
+    "doExpressions",
+    "numericSeparator",
+    "dynamicImport",
+    "jsx",
+    ["flow", { all: true, enums: true }]
+  ]
+};
+
 const babelSafeParserOptions = {
   sourceType: "module",
   allowImportExportEverywhere: true,
@@ -57,6 +80,30 @@ const babelSafeParserOptions = {
   ]
 };
 
+const babelSafeFlowParserOptions = {
+  sourceType: "module",
+  allowImportExportEverywhere: true,
+  allowAwaitOutsideFunction: true,
+  allowReturnOutsideFunction: true,
+  errorRecovery: true,
+  plugins: [
+    "optionalChaining",
+    "classProperties",
+    "decorators-legacy",
+    "exportDefaultFrom",
+    "doExpressions",
+    "numericSeparator",
+    "dynamicImport",
+    "flow"
+  ]
+};
+
+const shouldIncludeNodeModulesBundles =
+  process.env?.ASTGEN_INCLUDE_NODE_MODULES_BUNDLES === "true" ||
+  (process.env?.ASTGEN_IGNORE_DIRS &&
+    process.env.ASTGEN_IGNORE_DIRS.length > 0 &&
+    !process.env.ASTGEN_IGNORE_DIRS.toLowerCase().includes("node_modules"));
+
 /**
  * Return paths to all (j|tsx?) files.
  * Optionally includes specific bundled files from node_modules if:
@@ -66,7 +113,7 @@ const babelSafeParserOptions = {
 const getAllSrcJSAndTSFiles = (src) => {
   const filePattern = "\\.(js|jsx|cjs|mjs|ts|tsx|vue|svelte|xsjs|xsjslib|ejs)$";
   const bundledNodeModulesPattern =
-    "node_modules/.*\\.(bundle|dist|index|min|app)\\.(js|cjs|mjs)$";
+    "node_modules[\\\\/].*[\\\\/](?:.*\\.)?(bundle|dist|index|min|app)\\.(js|cjs|mjs)$";
 
   // Step 1: Collect all JS/TS files EXCLUDING node_modules
   const allFilesPromise = Promise.resolve(
@@ -79,14 +126,6 @@ const getAllSrcJSAndTSFiles = (src) => {
       true // ignore node_modules
     )
   );
-
-  // Step 2: Check if we should include node_modules bundles
-  const shouldIncludeNodeModulesBundles =
-    process.env?.ASTGEN_INCLUDE_NODE_MODULES_BUNDLES === "true" ||
-    (process.env?.ASTGEN_IGNORE_DIRS &&
-      process.env.ASTGEN_IGNORE_DIRS.length > 0 &&
-      !process.env.ASTGEN_IGNORE_DIRS.toLowerCase().includes("node_modules"));
-
   let bundledFilesPromise = Promise.resolve([]);
   if (shouldIncludeNodeModulesBundles) {
     bundledFilesPromise = Promise.resolve(
@@ -100,8 +139,7 @@ const getAllSrcJSAndTSFiles = (src) => {
       )
     );
   }
-
-  // Step 3: Combine both lists
+  // Step 2: Combine both lists
   return Promise.all([allFilesPromise, bundledFilesPromise]).then(
     ([allFiles, bundledFiles]) => [...allFiles, ...bundledFiles]
   );
@@ -110,21 +148,66 @@ const getAllSrcJSAndTSFiles = (src) => {
 /**
  * Convert a single JS/TS file to AST
  */
-const fileToJsAst = (file) => {
+const fileToJsAst = (file, projectType) => {
   if (file.endsWith(".vue") || file.endsWith(".svelte")) {
     return toVueAst(file);
   }
-  return codeToJsAst(readFileSync(file, "utf-8"));
+  if (file.endsWith(".ejs")) {
+    return toEjsAst(file);
+  }
+  return codeToJsAst(file, readFileSync(file, "utf-8"), projectType);
 };
 
 /**
  * Convert a single JS/TS code snippet to AST
  */
-const codeToJsAst = (code) => {
+const codeToJsAst = (file, code, projectType) => {
+  const isJs = /\.(js|jsx|cjs|mjs)$/.test(file);
+  if (isJs && projectType === "flow") {
+    try {
+      return parseHermes(code, {
+        sourceType: "unambiguous",
+        babel: true,
+        allowReturnOutsideFunction: true,
+        flow: "all",
+        sourceFilename: file,
+        tokens: true
+      });
+    } catch (err) {
+      // Ignore
+    }
+  }
+  // If user explicitly said 'flow', we try Babel-Flow first, then Babel-Standard.
+  // Otherwise, we try Babel-Standard (TS/ESNext) first, then Babel-Flow and finally hermes.
+  let primaryBabelOptions = babelParserOptions;
+  let secondaryBabelOptions = babelFlowParserOptions;
+  if (projectType === "flow") {
+    primaryBabelOptions = babelFlowParserOptions;
+    secondaryBabelOptions = babelParserOptions;
+  }
   try {
-    return parse(code, babelParserOptions);
-  } catch {
-    return parse(code, babelSafeParserOptions);
+    return parse(code, primaryBabelOptions);
+  } catch (errPrimary) {
+    try {
+      return parse(code, secondaryBabelOptions);
+    } catch (errSecondary) {
+      try {
+        return parse(code, babelSafeParserOptions);
+      } catch (errSafe) {
+        try {
+          return parse(code, babelSafeFlowParserOptions);
+        } catch (errSafeFlow) {
+          return parseHermes(code, {
+            sourceType: "unambiguous",
+            babel: true,
+            allowReturnOutsideFunction: true,
+            flow: "all",
+            sourceFilename: file,
+            tokens: true
+          });
+        }
+      }
+    }
   }
 };
 
@@ -168,19 +251,92 @@ const toVueAst = (file) => {
     .replace(vueTemplateRegex, function (match, grA, grB, grC) {
       return grA + grB.replaceAll("{{", "{ ").replaceAll("}}", " }") + grC;
     });
-  return codeToJsAst(cleanedCode);
+  return codeToJsAst(file, cleanedCode, "ts");
+};
+
+/**
+ * Convert a single EJS file to AST.
+ */
+const toEjsAst = (file) => {
+  const originalCode = readFileSync(file, "utf-8");
+  let arr = originalCode.split("");
+  const scriptRegex = /(<script>)([\s\S]*?)(<\/script>)/gi;
+  let match;
+
+  while ((match = scriptRegex.exec(originalCode)) !== null) {
+    const openStart = match.index;
+    const openLen = match[1].length;
+    arr[openStart] = "<";
+    arr[openStart + 1] = "%";
+    for (let i = 2; i < openLen; i++) arr[openStart + i] = " ";
+    const closeStart = match.index + match[0].length - match[3].length;
+    const closeLen = match[3].length;
+    arr[closeStart] = "%";
+    arr[closeStart + 1] = ">";
+    for (let i = 2; i < closeLen; i++) arr[closeStart + i] = " ";
+    const content = match[2];
+    const contentOffset = openStart + openLen;
+    const innerRegex = /(<%[=\-_#]?)([\s\S]*?)([-_#]?%>)/g;
+    let innerMatch;
+    while ((innerMatch = innerRegex.exec(content)) !== null) {
+      const innerAbsStart = contentOffset + innerMatch.index;
+      if (innerMatch[1] === "<%" && innerMatch[3] === "-%>") {
+        for (let k = 0; k < innerMatch[0].length; k++)
+          arr[innerAbsStart + k] = " ";
+      } else {
+        for (let k = 0; k < innerMatch[1].length; k++)
+          arr[innerAbsStart + k] = " ";
+        const endDelimStart =
+          innerAbsStart + innerMatch[0].length - innerMatch[3].length;
+        for (let k = 0; k < innerMatch[3].length; k++)
+          arr[endDelimStart + k] = " ";
+      }
+    }
+  }
+  const codeWithoutScriptTag = arr.join("");
+  const out = new Array(codeWithoutScriptTag.length).fill(" ");
+  for (let i = 0; i < codeWithoutScriptTag.length; i++) {
+    const c = codeWithoutScriptTag[i];
+    if (c === "\n" || c === "\r") out[i] = c;
+  }
+
+  const tagRegex = /(<%[=\-_#]?)([\s\S]*?)([-_#]?%>)/g;
+  let tagMatch;
+  while ((tagMatch = tagRegex.exec(codeWithoutScriptTag)) !== null) {
+    const [fullMatch, openTag, content, closeTag] = tagMatch;
+    if (openTag === "<%#" || content.trim().startsWith("include ")) continue;
+    const startIndex = tagMatch.index + openTag.length;
+    const endIndex = tagMatch.index + fullMatch.length - closeTag.length;
+    for (let k = startIndex; k < endIndex; k++) {
+      out[k] = codeWithoutScriptTag[k];
+    }
+    const trimmed = content.trim();
+    const needsSemi =
+      trimmed.length > 0 &&
+      !trimmed.endsWith("{") &&
+      !trimmed.endsWith("}") &&
+      !trimmed.endsWith(";");
+
+    if (needsSemi) {
+      out[endIndex] = ";";
+    }
+  }
+
+  return codeToJsAst(file, out.join(""), "ts");
 };
 
 function createTsc(srcFiles) {
   try {
     const program = tsc.createProgram(srcFiles, {
-      target: tsc.ScriptTarget.ES2020,
+      target: tsc.ScriptTarget.ES2022,
       module: tsc.ModuleKind.CommonJS,
+      moduleResolution: tsc.ModuleResolutionKind.Node10,
       allowImportingTsExtensions: false,
       allowArbitraryExtensions: false,
       allowSyntheticDefaultImports: true,
       allowUmdGlobalAccess: true,
       allowJs: true,
+      checkJs: true,
       allowUnreachableCode: true,
       allowUnusedLabels: true,
       alwaysStrict: false,
@@ -191,7 +347,7 @@ function createTsc(srcFiles) {
       noStrictGenericChecks: true,
       noUncheckedIndexedAccess: false,
       noPropertyAccessFromIndexSignature: false,
-      removeComments: true
+      lib: ["lib.es2022.d.ts", "lib.dom.d.ts"]
     });
     const typeChecker = program.getTypeChecker();
     const seenTypes = new Map();
@@ -213,48 +369,93 @@ function createTsc(srcFiles) {
     };
 
     const addType = (node) => {
-      let typeStr;
+      // STRUCTURAL/CONTAINER NODES
       if (
-        tsc.isSetAccessor(node) ||
-        tsc.isGetAccessor(node) ||
-        tsc.isGetAccessorDeclaration(node) ||
-        tsc.isCallSignatureDeclaration(node) ||
-        tsc.isIndexSignatureDeclaration(node) ||
-        tsc.isClassStaticBlockDeclaration(node) ||
-        tsc.isConstructSignatureDeclaration(node) ||
-        tsc.isMethodDeclaration(node) ||
-        tsc.isFunctionDeclaration(node) ||
-        tsc.isConstructorDeclaration(node) ||
-        tsc.isTypeAliasDeclaration(node) ||
-        tsc.isEnumDeclaration(node) ||
-        tsc.isNamespaceExportDeclaration(node) ||
-        tsc.isImportEqualsDeclaration(node)
+        node.kind === tsc.SyntaxKind.SourceFile ||
+        node.kind === tsc.SyntaxKind.Block ||
+        node.kind === tsc.SyntaxKind.ImportDeclaration ||
+        node.kind === tsc.SyntaxKind.ImportClause ||
+        node.kind === tsc.SyntaxKind.NamedImports ||
+        node.kind === tsc.SyntaxKind.NamespaceImport ||
+        node.kind === tsc.SyntaxKind.ExportDeclaration ||
+        node.kind === tsc.SyntaxKind.NamedExports ||
+        node.kind === tsc.SyntaxKind.TypeAliasDeclaration ||
+        node.kind === tsc.SyntaxKind.InterfaceDeclaration ||
+        node.kind === tsc.SyntaxKind.ModuleDeclaration
       ) {
-        const signature = typeChecker.getSignatureFromDeclaration(node);
-        const returnType = typeChecker.getReturnTypeOfSignature(signature);
-        typeStr = safeTypeToString(returnType);
-      } else if (tsc.isFunctionLike(node)) {
-        const funcType = typeChecker.getTypeAtLocation(node);
-        const funcSignature = typeChecker.getSignaturesOfType(
-          funcType,
-          tsc.SignatureKind.Call
-        )[0];
-        if (funcSignature) {
-          typeStr = safeTypeToString(funcSignature.getReturnType());
-        } else {
+        tsc.forEachChild(node, addType);
+        return;
+      }
+
+      let typeStr;
+
+      try {
+        // WRAPPER NODES
+        if (
+          (tsc.SyntaxKind.SatisfiesExpression &&
+            node.kind === tsc.SyntaxKind.SatisfiesExpression) ||
+          node.kind === tsc.SyntaxKind.AsExpression ||
+          node.kind === tsc.SyntaxKind.TypeAssertionExpression
+        ) {
           typeStr = safeTypeWithContextToString(
-            typeChecker.getTypeAtLocation(node),
-            node
+            typeChecker.getTypeAtLocation(node.expression),
+            node.expression
           );
         }
-      } else {
-        typeStr = safeTypeWithContextToString(
-          typeChecker.getTypeAtLocation(node),
-          node
-        );
-      }
-      if (!["any", "unknown", "any[]", "unknown[]"].includes(typeStr)) {
-        seenTypes.set(node.getStart(), typeStr);
+        // FUNCTION/METHOD SIGNATURES
+        else if (
+          tsc.isFunctionLike(node) ||
+          tsc.isMethodDeclaration(node) ||
+          tsc.isGetAccessor(node) ||
+          tsc.isSetAccessor(node) ||
+          tsc.isCallSignatureDeclaration(node) ||
+          tsc.isConstructSignatureDeclaration(node)
+        ) {
+          const signature = typeChecker.getSignatureFromDeclaration(node);
+          if (signature) {
+            const returnType = typeChecker.getReturnTypeOfSignature(signature);
+            typeStr = safeTypeToString(returnType);
+          } else {
+            const funcType = typeChecker.getTypeAtLocation(node);
+            const callSignatures = typeChecker.getSignaturesOfType(
+              funcType,
+              tsc.SignatureKind.Call
+            );
+            if (callSignatures.length > 0) {
+              typeStr = safeTypeToString(callSignatures[0].getReturnType());
+            }
+          }
+        }
+        // STANDARD EXPRESSIONS & IDENTIFIERS
+        else {
+          let typeObj = typeChecker.getTypeAtLocation(node);
+          if (
+            typeObj.isLiteral() ||
+            typeObj.flags & tsc.TypeFlags.BooleanLiteral
+          ) {
+            try {
+              typeObj = typeChecker.getBaseTypeOfLiteralType(typeObj);
+            } catch (e) {
+              // ignore
+            }
+          }
+          typeStr = safeTypeWithContextToString(typeObj, node);
+        }
+        if (
+          typeStr &&
+          ![
+            "any",
+            "unknown",
+            "any[]",
+            "unknown[]",
+            "error",
+            "/*unresolved*/ any"
+          ].includes(typeStr)
+        ) {
+          seenTypes.set(node.getStart(), typeStr);
+        }
+      } catch (err) {
+        // Silently fail on type resolution errors
       }
       tsc.forEachChild(node, addType);
     };
@@ -266,7 +467,6 @@ function createTsc(srcFiles) {
       seenTypes: seenTypes
     };
   } catch (err) {
-    console.warn("Retrieving types", err.message);
     return undefined;
   }
 }
@@ -285,13 +485,26 @@ const createJSAst = async (options) => {
     }
     let ts;
     if (options.tsTypes) {
-      const projectFiles = srcFiles.filter(
-        (file) => !file.includes("node_modules")
-      );
+      const projectFiles = !shouldIncludeNodeModulesBundles
+        ? srcFiles.filter((file) => !file.includes("node_modules"))
+        : srcFiles;
       ts = createTsc(projectFiles);
     }
     for (const chunk of chunks) {
       await Promise.all(chunk.map((file) => processFile(file, options, ts)));
+      if (typeof globalThis.gc === "function") {
+        try {
+          globalThis.gc();
+        } catch (e) {
+          // ignore
+        }
+      } else if (typeof Bun !== "undefined" && typeof Bun.gc === "function") {
+        try {
+          Bun.gc(true);
+        } catch (e) {
+          // ignore
+        }
+      }
     }
   } catch (err) {
     console.error(err);
@@ -300,7 +513,7 @@ const createJSAst = async (options) => {
 
 const processFile = (file, options, ts) => {
   try {
-    const ast = fileToJsAst(file);
+    const ast = fileToJsAst(file, options.type);
     writeAstFile(file, ast, options);
     if (ts) {
       try {
@@ -311,11 +524,11 @@ const processFile = (file, options, ts) => {
           ts.seenTypes.clear();
         }
       } catch (err) {
-        console.warn("Retrieving types", file, ":", err.message);
+        console.warn("Process file", file, ":", err.message);
       }
     }
   } catch (err) {
-    console.error(file, err.message);
+    console.error("Failure:", file, err?.message);
   }
 };
 
@@ -364,7 +577,10 @@ const writeAstFile = (file, ast, options) => {
     ast: ast
   };
   mkdirSync(dirname(outAstFile), { recursive: true });
-  writeFileSync(outAstFile, JSON.stringify(data, getCircularReplacer(), "  "));
+  writeFileSync(
+    outAstFile,
+    JSON.stringify(data, getCircularReplacer(), undefined)
+  );
   console.log("Converted AST for", relativePath, "to", outAstFile);
 };
 
@@ -374,7 +590,7 @@ const writeTypesFile = (file, seenTypes, options) => {
   mkdirSync(dirname(outTypeFile), { recursive: true });
   writeFileSync(
     outTypeFile,
-    JSON.stringify(Object.fromEntries(seenTypes), undefined, "  ")
+    JSON.stringify(Object.fromEntries(seenTypes), undefined, undefined)
   );
   console.log("Converted types for", relativePath, "to", outTypeFile);
 };
@@ -414,6 +630,7 @@ const start = async (options) => {
     case "javascript":
     case "typescript":
     case "ts":
+    case "flow":
       return await createJSAst(options);
     case "vue":
       return await createVueAst(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appthreat/atom-parsetools",
-  "version": "1.0.13",
+  "version": "1.0.16",
   "description": "Parsing tools that complement the @appthreat/atom project.",
   "main": "./index.js",
   "type": "module",
@@ -9,9 +9,10 @@
     "lint": "eslint *.mjs *.js"
   },
   "dependencies": {
-    "@appthreat/atom-common": "^1.0.13",
+    "@appthreat/atom-common": "^1.0.16",
     "@babel/parser": "^7.28.5",
     "typescript": "^5.9.3",
+    "hermes-parser": "^0.33.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {

package/plugins/composer/installed.php

@@ -1,9 +1,9 @@
 <?php return array(
     'root' => array(
         'name' => '__root__',
-        'pretty_version' => 'v2.4.4',
-        'version' => '2.4.4.0',
-        'reference' => '1dc241047acc51a1fd4d877d615a6589f16eaef9',
+        'pretty_version' => 'v2.4.7',
+        'version' => '2.4.7.0',
+        'reference' => '6480d9444422711061b2a514508ee8cf5feea3a8',
         'type' => 'library',
         'install_path' => __DIR__ . '/../../',
         'aliases' => array(),
@@ -11,9 +11,9 @@
     ),
     'versions' => array(
         '__root__' => array(
-            'pretty_version' => 'v2.4.4',
-            'version' => '2.4.4.0',
-            'reference' => '1dc241047acc51a1fd4d877d615a6589f16eaef9',
+            'pretty_version' => 'v2.4.7',
+            'version' => '2.4.7.0',
+            'reference' => '6480d9444422711061b2a514508ee8cf5feea3a8',
             'type' => 'library',
             'install_path' => __DIR__ . '/../../',
             'aliases' => array(),

package/plugins/rubyastgen/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/prism-1.6.0/gem_make.out

@@ -6,10 +6,10 @@ checking for whether -fvisibility=hidden is accepted as CFLAGS... yes
 creating Makefile
 
 current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/prism-1.6.0/ext/prism
-make DESTDIR\= sitearchdir\=./.gem.20251204-2999-73adu7 sitelibdir\=./.gem.20251204-2999-73adu7 clean
+make DESTDIR\= sitearchdir\=./.gem.20251218-3132-oi6x9k sitelibdir\=./.gem.20251218-3132-oi6x9k clean
 
 current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/prism-1.6.0/ext/prism
-make DESTDIR\= sitearchdir\=./.gem.20251204-2999-73adu7 sitelibdir\=./.gem.20251204-2999-73adu7
+make DESTDIR\= sitearchdir\=./.gem.20251218-3132-oi6x9k sitelibdir\=./.gem.20251218-3132-oi6x9k
 compiling api_node.c
 compiling api_pack.c
 compiling extension.c
@@ -37,8 +37,8 @@ compiling ./../../src/util/pm_strpbrk.c
 linking shared-object prism/prism.so
 
 current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/prism-1.6.0/ext/prism
-make DESTDIR\= sitearchdir\=./.gem.20251204-2999-73adu7 sitelibdir\=./.gem.20251204-2999-73adu7 install
-/usr/bin/install -c -m 0755 prism.so ./.gem.20251204-2999-73adu7/prism
+make DESTDIR\= sitearchdir\=./.gem.20251218-3132-oi6x9k sitelibdir\=./.gem.20251218-3132-oi6x9k install
+/usr/bin/install -c -m 0755 prism.so ./.gem.20251218-3132-oi6x9k/prism
 
 current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/prism-1.6.0/ext/prism
-make DESTDIR\= sitearchdir\=./.gem.20251204-2999-73adu7 sitelibdir\=./.gem.20251204-2999-73adu7 clean
+make DESTDIR\= sitearchdir\=./.gem.20251218-3132-oi6x9k sitelibdir\=./.gem.20251218-3132-oi6x9k clean

package/plugins/rubyastgen/bundle/ruby/3.4.0/extensions/x86_64-linux/3.4.0/racc-1.8.1/gem_make.out

@@ -3,16 +3,16 @@ current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-pars
 creating Makefile
 
 current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
-make DESTDIR\= sitearchdir\=./.gem.20251204-2999-8j064i sitelibdir\=./.gem.20251204-2999-8j064i clean
+make DESTDIR\= sitearchdir\=./.gem.20251218-3132-oho9ur sitelibdir\=./.gem.20251218-3132-oho9ur clean
 
 current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
-make DESTDIR\= sitearchdir\=./.gem.20251204-2999-8j064i sitelibdir\=./.gem.20251204-2999-8j064i
+make DESTDIR\= sitearchdir\=./.gem.20251218-3132-oho9ur sitelibdir\=./.gem.20251218-3132-oho9ur
 compiling cparse.c
 linking shared-object racc/cparse.so
 
 current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
-make DESTDIR\= sitearchdir\=./.gem.20251204-2999-8j064i sitelibdir\=./.gem.20251204-2999-8j064i install
-/usr/bin/install -c -m 0755 cparse.so ./.gem.20251204-2999-8j064i/racc
+make DESTDIR\= sitearchdir\=./.gem.20251218-3132-oho9ur sitelibdir\=./.gem.20251218-3132-oho9ur install
+/usr/bin/install -c -m 0755 cparse.so ./.gem.20251218-3132-oho9ur/racc
 
 current directory: /home/runner/work/atom/atom/wrapper/nodejs/packages/atom-parsetools/plugins/rubyastgen/bundle/ruby/3.4.0/gems/racc-1.8.1/ext/racc/cparse
-make DESTDIR\= sitearchdir\=./.gem.20251204-2999-8j064i sitelibdir\=./.gem.20251204-2999-8j064i clean
+make DESTDIR\= sitearchdir\=./.gem.20251218-3132-oho9ur sitelibdir\=./.gem.20251218-3132-oho9ur clean