breeze-bindgen 1.0.2 → 1.1.0

package/dist/core.mjs

@@ -0,0 +1,705 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/color-support/index.js
+var require_color_support = __commonJS({
+  "node_modules/color-support/index.js"(exports, module) {
+    module.exports = colorSupport({ alwaysReturn: true }, colorSupport);
+    function hasNone(obj, options) {
+      obj.level = 0;
+      obj.hasBasic = false;
+      obj.has256 = false;
+      obj.has16m = false;
+      if (!options.alwaysReturn) {
+        return false;
+      }
+      return obj;
+    }
+    function hasBasic(obj) {
+      obj.hasBasic = true;
+      obj.has256 = false;
+      obj.has16m = false;
+      obj.level = 1;
+      return obj;
+    }
+    function has256(obj) {
+      obj.hasBasic = true;
+      obj.has256 = true;
+      obj.has16m = false;
+      obj.level = 2;
+      return obj;
+    }
+    function has16m(obj) {
+      obj.hasBasic = true;
+      obj.has256 = true;
+      obj.has16m = true;
+      obj.level = 3;
+      return obj;
+    }
+    function colorSupport(options, obj) {
+      options = options || {};
+      obj = obj || {};
+      if (typeof options.level === "number") {
+        switch (options.level) {
+          case 0:
+            return hasNone(obj, options);
+          case 1:
+            return hasBasic(obj);
+          case 2:
+            return has256(obj);
+          case 3:
+            return has16m(obj);
+        }
+      }
+      obj.level = 0;
+      obj.hasBasic = false;
+      obj.has256 = false;
+      obj.has16m = false;
+      if (typeof process === "undefined" || !process || !process.stdout || !process.env || !process.platform) {
+        return hasNone(obj, options);
+      }
+      var env = options.env || process.env;
+      var stream = options.stream || process.stdout;
+      var term = options.term || env.TERM || "";
+      var platform = options.platform || process.platform;
+      if (!options.ignoreTTY && !stream.isTTY) {
+        return hasNone(obj, options);
+      }
+      if (!options.ignoreDumb && term === "dumb" && !env.COLORTERM) {
+        return hasNone(obj, options);
+      }
+      if (platform === "win32") {
+        return hasBasic(obj);
+      }
+      if (env.TMUX) {
+        return has256(obj);
+      }
+      if (!options.ignoreCI && (env.CI || env.TEAMCITY_VERSION)) {
+        if (env.TRAVIS) {
+          return has256(obj);
+        } else {
+          return hasNone(obj, options);
+        }
+      }
+      switch (env.TERM_PROGRAM) {
+        case "iTerm.app":
+          var ver = env.TERM_PROGRAM_VERSION || "0.";
+          if (/^[0-2]\./.test(ver)) {
+            return has256(obj);
+          } else {
+            return has16m(obj);
+          }
+        case "HyperTerm":
+        case "Hyper":
+          return has16m(obj);
+        case "MacTerm":
+          return has16m(obj);
+        case "Apple_Terminal":
+          return has256(obj);
+      }
+      if (/^xterm-256/.test(term)) {
+        return has256(obj);
+      }
+      if (/^screen|^xterm|^vt100|color|ansi|cygwin|linux/i.test(term)) {
+        return hasBasic(obj);
+      }
+      if (env.COLORTERM) {
+        return hasBasic(obj);
+      }
+      return hasNone(obj, options);
+    }
+  }
+});
+
+// node_modules/fancy-log/index.js
+var require_fancy_log = __commonJS({
+  "node_modules/fancy-log/index.js"(exports, module) {
+    "use strict";
+    var util = __require("util");
+    var Console = __require("console").Console;
+    var supportsColor = require_color_support();
+    var console = new Console({
+      stdout: process.stdout,
+      stderr: process.stderr,
+      colorMode: false
+    });
+    function hasFlag(flag) {
+      return process.argv.indexOf("--" + flag) !== -1;
+    }
+    function hasColors() {
+      if (hasFlag("no-color")) {
+        return false;
+      }
+      if (hasFlag("color")) {
+        return true;
+      }
+      if (supportsColor()) {
+        return true;
+      }
+      return false;
+    }
+    function Timestamp() {
+      this.now = /* @__PURE__ */ new Date();
+    }
+    Timestamp.prototype[util.inspect.custom] = function(depth, opts) {
+      var timestamp = this.now.toLocaleTimeString("en", { hour12: false });
+      return "[" + opts.stylize(timestamp, "date") + "]";
+    };
+    function getTimestamp() {
+      return util.inspect(new Timestamp(), { colors: hasColors() });
+    }
+    function log2() {
+      var time = getTimestamp();
+      process.stdout.write(time + " ");
+      console.log.apply(console, arguments);
+      return this;
+    }
+    function info() {
+      var time = getTimestamp();
+      process.stdout.write(time + " ");
+      console.info.apply(console, arguments);
+      return this;
+    }
+    function dir() {
+      var time = getTimestamp();
+      process.stdout.write(time + " ");
+      console.dir.apply(console, arguments);
+      return this;
+    }
+    function warn() {
+      var time = getTimestamp();
+      process.stderr.write(time + " ");
+      console.warn.apply(console, arguments);
+      return this;
+    }
+    function error() {
+      var time = getTimestamp();
+      process.stderr.write(time + " ");
+      console.error.apply(console, arguments);
+      return this;
+    }
+    module.exports = log2;
+    module.exports.info = info;
+    module.exports.dir = dir;
+    module.exports.warn = warn;
+    module.exports.error = error;
+  }
+});
+
+// core.ts
+var import_fancy_log = __toESM(require_fancy_log());
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+// c-type-parser.ts
+var CTypeParser = class {
+  tokens = [];
+  cursor = 0;
+  lex(str) {
+    this.tokens = [];
+    let current = "";
+    const BREAK_TOKENS = [" ", "(", ")", ",", "<", ">"];
+    for (let i = 0; i < str.length; i++) {
+      const c = str[i];
+      if (BREAK_TOKENS.includes(c)) {
+        if (current.length > 0) {
+          this.tokens.push(current);
+          current = "";
+        }
+        if (c !== " ") {
+          this.tokens.push(c);
+        }
+      } else {
+        current += c;
+      }
+    }
+    if (current.length > 0) {
+      this.tokens.push(current);
+    }
+  }
+  parse(str = null, typeTransformer = (orig) => orig) {
+    if (str) {
+      this.lex(str);
+      this.cursor = 0;
+    }
+    const type = {
+      argsFunc: [],
+      argsTemplate: [],
+      function: false,
+      template: false,
+      type: ""
+    };
+    do {
+      const parseCommaList = (arr) => {
+        do {
+          const res = this.parse(null, typeTransformer);
+          if (res)
+            arr.push(res);
+        } while (this.eat(","));
+      };
+      if (this.eat("(")) {
+        type.function = true;
+        if (!this.next(")"))
+          parseCommaList(type.argsFunc);
+        this.eat(")", true);
+      } else if (this.eat("<")) {
+        type.template = true;
+        if (!this.next(">"))
+          parseCommaList(type.argsTemplate);
+        this.eat(">", true);
+      } else {
+        type.type = typeTransformer(this.tokens[this.cursor]);
+        this.cursor++;
+      }
+      if (this.next("(") || this.next("<")) {
+        continue;
+      }
+      break;
+    } while (true);
+    return type;
+  }
+  eat(token, force = false) {
+    if (this.next(token)) {
+      this.cursor++;
+      return true;
+    } else {
+      if (force) throw new Error(`Excepted: ${token}, found ${this.next()} in ${this.tokens.join(" ")}`);
+    }
+    return false;
+  }
+  next(token = null) {
+    if (this.tokens[this.cursor] === token || !token) {
+      return this.tokens[this.cursor];
+    }
+    return false;
+  }
+  formatToC(node) {
+    let str = node.type;
+    if (node.template) {
+      str += "<" + node.argsTemplate.map((a) => this.formatToC(a)).join(", ") + ">";
+    }
+    if (node.function) {
+      str += "(" + node.argsFunc.map((a) => this.formatToC(a)).join(", ") + ")";
+    }
+    return str;
+  }
+  formatToTypeScript(node, namespace = "") {
+    if (node.type.startsWith(namespace))
+      node.type = node.type.slice(namespace.length);
+    node.type = node.type.split("::").filter(Boolean).join(".");
+    const typeMap = {
+      "int": "number",
+      "float": "number",
+      "double": "number",
+      "std.string": "string",
+      "std.vector": "Array",
+      "bool": "boolean"
+    };
+    let tsBasicType = (typeMap[node.type] ?? node.type) + (node.template ? "<" + node.argsTemplate.map((a) => this.formatToTypeScript(a, namespace)).join(", ") + ">" : "");
+    const ignoreTypes = ["std.variant", "std.shared_ptr", "std.function"];
+    if (ignoreTypes.includes(node.type)) {
+      tsBasicType = node.argsTemplate.map((a) => this.formatToTypeScript(a, namespace)).join(" | ");
+    } else if (node.type === "std.optional") {
+      tsBasicType = `${this.formatToTypeScript(node.argsTemplate[0], namespace)} | undefined`;
+    } else if (node.type === "std.pair" || node.type === "std.tuple") {
+      tsBasicType = node.argsTemplate.map((a) => this.formatToTypeScript(a, namespace)).join(", ");
+      tsBasicType = `[${tsBasicType}]`;
+    }
+    if (node.function) {
+      return `((${node.argsFunc.map((a) => this.formatToTypeScript(a, namespace)).map((v, i) => `arg${i + 1}: ${v}`).join(", ")}) => ${tsBasicType})`;
+    }
+    return tsBasicType;
+  }
+};
+var cTypeToTypeScript = (str, namespace) => {
+  const parser = new CTypeParser();
+  parser.lex(str);
+  const res = parser.parse();
+  return parser.formatToTypeScript(res, namespace);
+};
+
+// core.ts
+var DEFAULT_CPP_BINDING_OUTPUT_FILE = "binding_qjs.h";
+var DEFAULT_TS_DEFINITION_OUTPUT_FILE = "binding_types.d.ts";
+var DEFAULT_NAME_FILTER = "breeze::js::";
+function parseFunctionQualType(type) {
+  let State;
+  ((State2) => {
+    State2[State2["ReturnType"] = 0] = "ReturnType";
+    State2[State2["Args"] = 1] = "Args";
+    State2[State2["Done"] = 2] = "Done";
+  })(State || (State = {}));
+  let state = 0 /* ReturnType */;
+  let returnType = "";
+  let currentArg = "";
+  let args = [];
+  let depth = 0;
+  let angleBracketDepth = 0;
+  for (let i = 0; i < type.length; i++) {
+    const char = type[i];
+    if (char === "<") angleBracketDepth++;
+    else if (char === ">") angleBracketDepth--;
+    switch (state) {
+      case 0 /* ReturnType */:
+        if (char === "(" && angleBracketDepth === 0) {
+          state = 1 /* Args */;
+          returnType = returnType.trim();
+        } else {
+          returnType += char;
+        }
+        break;
+      case 1 /* Args */:
+        if (char === "(") depth++;
+        if (char === ")") {
+          if (depth === 0 && angleBracketDepth === 0) {
+            if (currentArg.trim()) args.push(currentArg.trim());
+            state = 2 /* Done */;
+            break;
+          }
+          depth--;
+        }
+        if (char === "," && depth === 0 && angleBracketDepth === 0) {
+          args.push(currentArg.trim());
+          currentArg = "";
+        } else {
+          currentArg += char;
+        }
+        break;
+    }
+  }
+  if (state !== 2 /* Done */) throw new Error("Invalid function type");
+  return { returnType, args };
+}
+function processAstAndGenerateCode(astArr, originalCppFilePath, nameFilter, additionalTypes) {
+  const origFileContent = readFileSync(originalCppFilePath, "utf-8").split("\n").map((v) => v.trim());
+  const structNames = [];
+  const resolveUnderPath = (path, resolveName) => {
+    const ns = path.join("::");
+    const fullName = `${ns}::${resolveName}`;
+    if (structNames.includes(fullName)) return fullName;
+    if (path.length > 1) {
+      const parentPath = path.slice(0, -1);
+      const parentFullName = resolveUnderPath(parentPath, resolveName);
+      if (parentFullName) return parentFullName;
+    }
+    return resolveName;
+  };
+  const ctypeToQualified = (type, path) => {
+    const parser = new CTypeParser();
+    const parsed = parser.parse(type, (name) => resolveUnderPath(path, name));
+    return parser.formatToC(parsed);
+  };
+  let binding = `// This file is generated by bindgen
+// Do not modify this file manually!
+
+#pragma once
+#include "binding_types.h" // Assuming this will be in the same output directory
+#include "quickjs.h"
+#include "quickjspp.hpp"
+
+template <typename T>
+struct js_bind {
+    static void bind(qjs::Context::Module &mod) {}
+};
+`;
+  let typescriptDef = `// This file is generated by bindgen
+// Do not modify this file manually!
+
+declare module 'mshell' { // TODO: Make module name configurable or derive
+`;
+  const generateForRecordDecl = (node_struct, path) => {
+    if (node_struct.kind !== "CXXRecordDecl") throw new Error("Node is not a RecordDecl");
+    const structName = node_struct.name;
+    const fields = [];
+    const methods = [];
+    const bases = node_struct.bases?.filter((base) => !base.type.qualType.includes("std::")).map((base) => ({
+      access: base.access,
+      type: ctypeToQualified(base.type.qualType, path)
+    })) || [];
+    if (!node_struct.inner) return;
+    for (const node of node_struct.inner) {
+      if (node.name?.startsWith("$")) continue;
+      const lineNum = node.loc?.line;
+      let comment = "";
+      if (lineNum) {
+        let rangeCommentCnt = 0;
+        for (let i = lineNum - 2; i >= 0; i--) {
+          const line = origFileContent[i];
+          if (!line) continue;
+          if (line.startsWith("//")) {
+            comment = line.substring(2) + "\n" + comment;
+            continue;
+          }
+          if (line.startsWith("/*")) rangeCommentCnt++;
+          if (line.endsWith("*/")) rangeCommentCnt--;
+          if (rangeCommentCnt === 0 && (line.startsWith("/*") || line.endsWith("*/"))) {
+            if (line.startsWith("/*") && line.endsWith("*/")) {
+              comment = line.substring(2, line.length - 2) + "\n" + comment;
+            } else if (line.startsWith("/*")) {
+            } else if (line.endsWith("*/")) {
+              comment = line.substring(0, line.length - 2) + "\n" + comment;
+            }
+            break;
+          } else if (rangeCommentCnt > 0 || line.endsWith("*/")) {
+            comment = line.replaceAll("/*", "").replaceAll("*/", "*") + "\n" + comment;
+          } else if (rangeCommentCnt === 0 && !line.startsWith("//") && !line.startsWith("/*") && !line.endsWith("*/")) {
+            break;
+          }
+        }
+      }
+      comment = comment.trim();
+      if (node.kind === "FieldDecl") {
+        fields.push({
+          name: node.name,
+          type: ctypeToQualified(node.type.qualType, path),
+          comment: comment.length > 0 ? comment : void 0
+        });
+      }
+      if (node.kind === "CXXMethodDecl") {
+        const parsed = parseFunctionQualType(node.type.qualType);
+        if (["operator="].includes(node.name)) continue;
+        const argNames = [];
+        if (node.inner) {
+          for (const arg of node.inner) {
+            if (arg.kind === "ParmVarDecl") argNames.push(arg.name);
+          }
+        }
+        methods.push({
+          name: node.name,
+          returnType: ctypeToQualified(parsed.returnType, path),
+          args: parsed.args.map((arg) => ctypeToQualified(arg, path)),
+          static: node.storageClass === "static",
+          comment: comment.length > 0 ? comment : void 0,
+          argNames
+        });
+      }
+    }
+    const fullName = path.join("::") + "::" + structName;
+    if (bases.length === 0) {
+      binding += `
+template <> struct qjs::js_traits<${fullName}> {
+    static ${fullName} unwrap(JSContext *ctx, JSValueConst v) {
+        ${fullName} obj;
+`;
+      for (const field of fields) {
+        binding += `
+        obj.${field.name} = js_traits<${field.type}>::unwrap(ctx, JS_GetPropertyStr(ctx, v, "${field.name}"));
+`;
+      }
+      binding += `
+        return obj;
+    }
+
+    static JSValue wrap(JSContext *ctx, const ${fullName} &val) noexcept {
+        JSValue obj = JS_NewObject(ctx);
+`;
+      for (const field of fields) {
+        binding += `
+        JS_SetPropertyStr(ctx, obj, "${field.name}", js_traits<${field.type}>::wrap(ctx, val.${field.name}));
+`;
+      }
+      binding += `
+        return obj;
+    }
+};`;
+    }
+    const jsNamespaceName = fullName.replace(nameFilter, "");
+    binding += `
+template<> struct js_bind<${fullName}> {
+    static void bind(qjs::Context::Module &mod) {
+        mod.class_<${fullName}>("${jsNamespaceName}")
+            .constructor<>()`;
+    if (bases.length > 0) {
+      binding += `
+                .base<${bases[0].type}>()`;
+    }
+    for (const method of methods) {
+      binding += `
+                .${method.static ? "static_" : ""}fun<&${fullName}::${method.name}>("${method.name}")`;
+    }
+    for (const field of fields) {
+      binding += `
+                .property<&${fullName}::${field.name}>("${field.name}")`;
+    }
+    binding += `
+            ;
+    }
+};
+`;
+    const tsNamespaceParts = jsNamespaceName.split("::");
+    const tsClassName = tsNamespaceParts.pop() || structName;
+    const tsNamespace = tsNamespaceParts.join(".");
+    if (tsNamespace) typescriptDef += `
+namespace ${tsNamespace} {`;
+    typescriptDef += `
+export class ${tsClassName}${bases.length > 0 ? ` extends ${bases.map((base) => base.type.split("::").pop() ?? base.type).join(", ")}` : ""} {`;
+    fields.forEach((field) => {
+      let fieldDef = `${field.name}${field.type.startsWith("std::optional") ? "?" : ""}: ${cTypeToTypeScript(field.type, nameFilter)}`;
+      if (field.comment) {
+        fieldDef = `
+    /**
+     * ${field.comment.split("\n").join("\n     * ")}
+     */
+    ${fieldDef}`;
+      }
+      typescriptDef += `
+	${fieldDef.trim()}`;
+    });
+    methods.forEach((method) => {
+      let methodDef = `${method.static ? "static " : ""}${method.name}(${method.argNames && method.argNames.length > 0 ? method.args.map((arg, i) => `${method.argNames[i] || `arg${i}`}: ${cTypeToTypeScript(arg, nameFilter)}`).join(", ") : ""}): ${cTypeToTypeScript(method.returnType, nameFilter)}`;
+      let comments = "";
+      if (method.comment) comments += method.comment;
+      if (comments || method.argNames && method.argNames.length > 0) {
+        methodDef = `
+    /**
+     * ${comments.split("\n").join("\n     * ")}
+     ${method.argNames && method.argNames.length > 0 ? `* @param ${method.args.map((arg, i) => `${method.argNames[i] || `arg${i}`}${cTypeToTypeScript(arg, nameFilter) === "any" ? "" : `: ${cTypeToTypeScript(arg, nameFilter)}`}`).join("\n     * @param ")}
+     *` : ""} @returns ${cTypeToTypeScript(method.returnType, nameFilter)}
+     */
+    ${methodDef}`;
+      }
+      typescriptDef += `
+	${methodDef.trim()}`;
+    });
+    typescriptDef += `
+}`;
+    if (tsNamespace) typescriptDef += `
+}`;
+  };
+  const enumerateStructDecls = (node, callback, path = ["breeze"]) => {
+    if (node.kind === "CXXRecordDecl" && node.name && node.inner) {
+      callback(node, path);
+    }
+    if (node.inner) {
+      for (const child of node.inner) {
+        enumerateStructDecls(child, callback, [...path, node.name || ""]);
+      }
+    }
+  };
+  for (const ast of astArr) {
+    enumerateStructDecls(ast, (node, path) => {
+      if (node.name) structNames.push(path.join("::") + "::" + node.name);
+    });
+  }
+  for (const ast of astArr) {
+    enumerateStructDecls(ast, (node, path) => {
+      if (node.kind === "CXXRecordDecl" && node.name) generateForRecordDecl(node, path);
+    });
+  }
+  binding += `
+inline void bindAll(qjs::Context::Module &mod) {
+`;
+  for (const structName of structNames) {
+    binding += `
+    js_bind<${structName}>::bind(mod);
+`;
+  }
+  binding += `
+}
+`;
+  typescriptDef += `
+}
+`;
+  typescriptDef += "\n" + additionalTypes;
+  return { cppBinding: binding, tsDefinitions: typescriptDef };
+}
+function generateBindingsAndDefinitions(config) {
+  const {
+    cppFilePath,
+    outputDir,
+    clangPath = "clang++",
+    cppBindingOutputFile = DEFAULT_CPP_BINDING_OUTPUT_FILE,
+    tsDefinitionOutputFile = DEFAULT_TS_DEFINITION_OUTPUT_FILE,
+    additionalTypes = "",
+    nameFilter = DEFAULT_NAME_FILTER
+  } = config;
+  const absoluteCppFilePath = resolvePath(cppFilePath);
+  const absoluteOutputDir = resolvePath(outputDir);
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const bindgenDir = dirname(currentFilePath);
+  const clangArgs = [
+    "-Xclang",
+    "-ast-dump=json",
+    "-fsyntax-only",
+    "-Xclang",
+    `-ast-dump-filter=${nameFilter.slice(0, -2)}`,
+    "-std=c++2c",
+    absoluteCppFilePath
+  ];
+  (0, import_fancy_log.default)(`Executing: ${clangPath} ${clangArgs.join(" ")}`);
+  const clangProcess = spawnSync(clangPath, clangArgs, { encoding: "utf-8", shell: true });
+  if (clangProcess.error) {
+    import_fancy_log.default.error(`Failed to start clang++: ${clangProcess.error.message}`);
+    if (clangProcess.error.code === "ENOENT") {
+      throw new Error(`clang++ not found at path "${clangPath}". Please ensure it's installed and in your PATH, or provide a correct path.`);
+    }
+    throw clangProcess.error;
+  }
+  if (clangProcess.stderr && clangProcess.stderr.length > 0) {
+    import_fancy_log.default.warn(`clang++ stderr:
+${clangProcess.stderr}`);
+  }
+  if (!clangProcess.stdout || clangProcess.stdout.trim().length === 0) {
+    throw new Error(`clang++ produced no output (stdout). AST generation failed. Error: ${clangProcess.stderr}`);
+  }
+  let astText = clangProcess.stdout;
+  if (!astText.trim().startsWith("[")) {
+    astText = "[" + astText.trim().replace(/}\s*{/g, "},{") + "]";
+  }
+  let astArr;
+  try {
+    astArr = JSON.parse(astText);
+  } catch (e) {
+    import_fancy_log.default.error("Failed to parse AST JSON:", e);
+    import_fancy_log.default.error("Problematic AST JSON content (first 1000 chars):", astText.substring(0, 1e3));
+    throw new Error(`Failed to parse AST JSON from clang++. Check for errors in C++ code or clang++ execution.`);
+  }
+  if (!astArr || astArr.length === 0) {
+    import_fancy_log.default.warn(`No AST data was parsed. This might mean the ast-dump-filter ("${nameFilter.slice(0, -2)}") didn't match anything, or the input file is empty or has no relevant declarations.`);
+  }
+  const { cppBinding, tsDefinitions } = processAstAndGenerateCode(astArr, absoluteCppFilePath, nameFilter, additionalTypes);
+  if (!existsSync(absoluteOutputDir)) {
+    try {
+      mkdirSync(absoluteOutputDir, { recursive: true });
+    } catch (e) {
+      throw new Error(`Failed to create output directory ${absoluteOutputDir}: ${e.message}`);
+    }
+  }
+  writeFileSync(join(absoluteOutputDir, cppBindingOutputFile), cppBinding);
+  writeFileSync(join(absoluteOutputDir, tsDefinitionOutputFile), tsDefinitions);
+  (0, import_fancy_log.default)(`Bindings generated successfully in ${absoluteOutputDir}`);
+}
+export {
+  generateBindingsAndDefinitions
+};