@bis-toolkit/cppparser 1.0.0

package/dist/index.js

@@ -0,0 +1,772 @@
+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');
+});
+
+// src/lexer.ts
+var CfgKeywords = /* @__PURE__ */ new Set([
+  "class",
+  "delete",
+  "enum",
+  "true",
+  "false",
+  "null",
+  "NULL"
+]);
+var CfgPunctuations = /* @__PURE__ */ new Set([
+  "{",
+  "}",
+  ";",
+  ":",
+  "=",
+  "[",
+  "]",
+  ",",
+  "+",
+  "-",
+  "*",
+  "/"
+]);
+var CfgOperators = /* @__PURE__ */ new Set([
+  "+=",
+  "-=",
+  "=",
+  "+",
+  "-",
+  "*",
+  "/"
+]);
+var TokenKind = /* @__PURE__ */ ((TokenKind2) => {
+  TokenKind2[TokenKind2["Keyword"] = 0] = "Keyword";
+  TokenKind2[TokenKind2["Identifier"] = 1] = "Identifier";
+  TokenKind2[TokenKind2["Number"] = 2] = "Number";
+  TokenKind2[TokenKind2["String"] = 3] = "String";
+  TokenKind2[TokenKind2["Punctuation"] = 4] = "Punctuation";
+  TokenKind2[TokenKind2["EOF"] = 5] = "EOF";
+  TokenKind2[TokenKind2["Unknown"] = 6] = "Unknown";
+  return TokenKind2;
+})(TokenKind || {});
+var isCfgKeyword = (value) => {
+  return CfgKeywords.has(value);
+};
+var isCfgPunctuation = (value) => {
+  return CfgPunctuations.has(value);
+};
+var operators = Array.from(CfgOperators).sort((a, b) => b.length - a.length);
+var lex = (input) => {
+  const tokens = [];
+  let i = 0;
+  let currentLine = 1;
+  let currentColumn = 1;
+  const push = (kind, value, start, end, tokenLine, tokenColumn) => {
+    tokens.push({ kind, value, start, end, line: tokenLine, column: tokenColumn });
+  };
+  const updatePosition = (text) => {
+    for (const char of text) {
+      if (char === "\n") {
+        currentLine++;
+        currentColumn = 1;
+      } else {
+        currentColumn++;
+      }
+    }
+  };
+  while (i < input.length) {
+    while (i < input.length && /\s/.test(input[i])) {
+      updatePosition(input[i]);
+      i++;
+    }
+    if (i >= input.length) {
+      break;
+    }
+    const start = i;
+    const startLine = currentLine;
+    const startColumn = currentColumn;
+    if (input[i] === "/" && i + 1 < input.length) {
+      if (input[i + 1] === "/") {
+        while (i < input.length && input[i] !== "\n") {
+          i++;
+        }
+        continue;
+      } else if (input[i + 1] === "*") {
+        i += 2;
+        while (i + 1 < input.length) {
+          if (input[i] === "*" && input[i + 1] === "/") {
+            i += 2;
+            break;
+          }
+          i++;
+        }
+        continue;
+      }
+    }
+    let matched = false;
+    for (const op of operators) {
+      if (input.startsWith(op, i)) {
+        push(4 /* Punctuation */, op, i, i + op.length, startLine, startColumn);
+        updatePosition(op);
+        i += op.length;
+        matched = true;
+        break;
+      }
+    }
+    if (matched) {
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(input[i])) {
+      while (i < input.length && /[a-zA-Z0-9_]/.test(input[i])) {
+        i++;
+      }
+      const value = input.slice(start, i);
+      const kind = isCfgKeyword(value) ? 0 /* Keyword */ : 1 /* Identifier */;
+      push(kind, value, start, i, startLine, startColumn);
+      updatePosition(value);
+    } else if (/\d/.test(input[i])) {
+      const numStart = i;
+      while (i < input.length && /\d/.test(input[i])) {
+        i++;
+      }
+      if (i < input.length && input[i] === ".") {
+        i++;
+        while (i < input.length && /\d/.test(input[i])) {
+          i++;
+        }
+      }
+      if (i < input.length && /[eE]/.test(input[i])) {
+        const ePos = i;
+        i++;
+        if (i < input.length && /[+-]/.test(input[i])) {
+          i++;
+        }
+        if (i < input.length && /\d/.test(input[i])) {
+          while (i < input.length && /\d/.test(input[i])) {
+            i++;
+          }
+        } else {
+          i = ePos;
+        }
+      }
+      if (i < input.length && /[a-zA-Z_]/.test(input[i])) {
+        while (i < input.length && /[a-zA-Z0-9_]/.test(input[i])) {
+          i++;
+        }
+        const value2 = input.slice(numStart, i);
+        push(1 /* Identifier */, value2, numStart, i, startLine, startColumn);
+        updatePosition(value2);
+        continue;
+      }
+      const value = input.slice(numStart, i);
+      push(2 /* Number */, value, numStart, i, startLine, startColumn);
+      updatePosition(value);
+    } else if (input[i] === '"') {
+      const stringStart = i;
+      i++;
+      while (i < input.length) {
+        if (input[i] === '"') {
+          if (i + 1 < input.length && input[i + 1] === '"') {
+            i += 2;
+            continue;
+          }
+          break;
+        }
+        i++;
+      }
+      const value = input.slice(stringStart + 1, i);
+      push(3 /* String */, value, stringStart, i + 1, startLine, startColumn);
+      updatePosition(input.slice(stringStart, i + 1));
+      i++;
+    } else if (isCfgPunctuation(input[i])) {
+      push(4 /* Punctuation */, input[i], start, i + 1, startLine, startColumn);
+      updatePosition(input[i]);
+      i++;
+    } else {
+      const unknownStart = i;
+      while (i < input.length && !/[a-zA-Z_]/.test(input[i]) && !/\d/.test(input[i]) && input[i] !== '"' && !isCfgPunctuation(input[i]) && !/\s/.test(input[i])) {
+        i++;
+      }
+      const value = input.slice(unknownStart, i);
+      push(6 /* Unknown */, value, unknownStart, i, startLine, startColumn);
+      updatePosition(value);
+    }
+  }
+  return tokens;
+};
+
+// src/parser.ts
+var Parser = class {
+  constructor(input, filename) {
+    this.current = 0;
+    this.tokens = lex(input);
+    this.filename = filename ?? "<unknown>";
+  }
+  peek() {
+    return this.current < this.tokens.length ? this.tokens[this.current] : null;
+  }
+  advance() {
+    if (this.current < this.tokens.length) {
+      return this.tokens[this.current++];
+    }
+    return null;
+  }
+  consume(kind, value) {
+    const token = this.peek();
+    if (token?.kind !== kind || value && token.value !== value) {
+      const expected = value ? `'${value}'` : TokenKind[kind];
+      const got = token ? `${TokenKind[token.kind]} '${token.value}'` : "EOF";
+      const location = token ? `${this.filename}:${token.line}:${token.column}` : this.filename;
+      throw new Error(`${location}: Expected ${expected}, got ${got}`);
+    }
+    return this.advance();
+  }
+  isAtEnd() {
+    return this.current >= this.tokens.length;
+  }
+  parseType() {
+    const token = this.peek();
+    if (!token) {
+      throw new Error(`${this.filename}: Unexpected end of input`);
+    }
+    if (token.kind === 4 /* Punctuation */ && (token.value === "-" || token.value === "+")) {
+      this.advance();
+      const numToken = this.peek();
+      if (numToken?.kind === 2 /* Number */) {
+        this.advance();
+        const value = parseFloat(numToken.value);
+        return token.value === "-" ? -value : value;
+      }
+      throw new Error(`${this.filename}:${token.line}:${token.column}: Expected number after '${token.value}'`);
+    }
+    if (token.kind === 2 /* Number */) {
+      this.advance();
+      return parseFloat(token.value);
+    } else if (token.kind === 3 /* String */) {
+      this.advance();
+      return token.value;
+    } else if (token.kind === 0 /* Keyword */) {
+      if (token.value === "true") {
+        this.advance();
+        return true;
+      } else if (token.value === "false") {
+        this.advance();
+        return false;
+      } else if (token.value === "null" || token.value === "NULL") {
+        this.advance();
+        return null;
+      }
+    }
+    throw new Error(`${this.filename}:${token.line}:${token.column}: Unexpected token for type: ${TokenKind[token.kind]} '${token.value}'`);
+  }
+  parseExpression() {
+    const token = this.peek();
+    if (token?.kind === 4 /* Punctuation */ && token.value === "{") {
+      this.advance();
+      const elements = this.parseArrayElements();
+      this.consume(4 /* Punctuation */, "}");
+      return elements;
+    }
+    return this.parseType();
+  }
+  parseArrayElements() {
+    const elements = [];
+    while (!this.isAtEnd()) {
+      const token = this.peek();
+      if (token?.value === "}") {
+        break;
+      }
+      elements.push(this.parseExpression());
+      const comma = this.peek();
+      if (comma?.value === ",") {
+        this.advance();
+      } else {
+        break;
+      }
+    }
+    return elements;
+  }
+  parseVariable() {
+    const name = this.consume(1 /* Identifier */)?.value;
+    if (!name) {
+      throw new Error(`${this.filename}: Expected variable name`);
+    }
+    const next = this.peek();
+    if (next?.value === "[") {
+      this.consume(4 /* Punctuation */, "[");
+      this.consume(4 /* Punctuation */, "]");
+      const op = this.consume(4 /* Punctuation */);
+      if (!op) {
+        throw new Error(`${this.filename}: Unexpected end of input after array variable '${name}'`);
+      }
+      if (op.value !== "=" && op.value !== "+=" && op.value !== "-=") {
+        throw new Error(`${this.filename}:${op.line}:${op.column}: Invalid operator for array: '${op.value}'`);
+      }
+      this.consume(4 /* Punctuation */, "{");
+      const elements = this.parseArrayElements();
+      this.consume(4 /* Punctuation */, "}");
+      this.consume(4 /* Punctuation */, ";");
+      if (op.value === "=") {
+        return {
+          kind: "array",
+          name,
+          values: elements
+        };
+      } else if (op.value === "+=") {
+        return {
+          kind: "array-extend",
+          name,
+          values: elements
+        };
+      } else {
+        return {
+          kind: "array-shrink",
+          name,
+          values: elements
+        };
+      }
+    } else {
+      this.consume(4 /* Punctuation */, "=");
+      const value = this.parseExpression();
+      this.consume(4 /* Punctuation */, ";");
+      return {
+        kind: "variable",
+        name,
+        value
+      };
+    }
+  }
+  parseClass() {
+    this.consume(0 /* Keyword */, "class");
+    const name = this.consume(1 /* Identifier */)?.value;
+    if (!name) {
+      throw new Error(`${this.filename}: Expected class name`);
+    }
+    let baseClassName;
+    const colon = this.peek();
+    if (colon?.value === ":") {
+      this.advance();
+      baseClassName = this.consume(1 /* Identifier */)?.value;
+    }
+    const brace = this.peek();
+    if (brace?.value === "{") {
+      this.advance();
+      const properties = /* @__PURE__ */ new Map();
+      while (!this.isAtEnd()) {
+        const token = this.peek();
+        if (!token || token.value === "}") {
+          break;
+        }
+        if (token.kind === 0 /* Keyword */ && token.value === "class") {
+          const nestedClass = this.parseClass();
+          properties.set(nestedClass.name, nestedClass);
+        } else if (token.kind === 0 /* Keyword */ && token.value === "delete") {
+          const deleteStmt = this.parseDelete();
+          properties.set(deleteStmt.name, deleteStmt);
+        } else {
+          const prop = this.parseVariable();
+          properties.set(prop.name, prop);
+        }
+      }
+      this.consume(4 /* Punctuation */, "}");
+      this.consume(4 /* Punctuation */, ";");
+      return {
+        kind: "class",
+        name,
+        baseClassName,
+        properties
+      };
+    } else {
+      this.consume(4 /* Punctuation */, ";");
+      return {
+        kind: "prototype",
+        name,
+        baseClassName
+      };
+    }
+  }
+  parseDelete() {
+    this.consume(0 /* Keyword */, "delete");
+    const name = this.consume(1 /* Identifier */)?.value;
+    if (!name) {
+      throw new Error(`${this.filename}: Expected delete name`);
+    }
+    this.consume(4 /* Punctuation */, ";");
+    return {
+      kind: "delete",
+      name
+    };
+  }
+  parseEnum() {
+    this.consume(0 /* Keyword */, "enum");
+    this.consume(4 /* Punctuation */, "{");
+    const members = [];
+    let nextValue = 0;
+    while (!this.isAtEnd()) {
+      const token = this.peek();
+      if (token?.value === "}") {
+        break;
+      }
+      const memberName = this.consume(1 /* Identifier */)?.value;
+      if (!memberName) {
+        throw new Error(`${this.filename}: Expected enum member name`);
+      }
+      let value;
+      const eq = this.peek();
+      if (eq?.value === "=") {
+        this.advance();
+        const numToken = this.consume(2 /* Number */);
+        if (!numToken) {
+          throw new Error(`${this.filename}: Expected number for enum member value`);
+        }
+        value = parseFloat(numToken.value);
+        nextValue = value + 1;
+      } else {
+        value = nextValue++;
+      }
+      members.push({ name: memberName, value });
+      const comma = this.peek();
+      if (comma?.value === ",") {
+        this.advance();
+      } else {
+        break;
+      }
+    }
+    this.consume(4 /* Punctuation */, "}");
+    this.consume(4 /* Punctuation */, ";");
+    return {
+      kind: "enum",
+      members
+    };
+  }
+  parse() {
+    const statements = [];
+    while (!this.isAtEnd()) {
+      const token = this.peek();
+      if (!token) {
+        break;
+      }
+      if (token.kind === 1 /* Identifier */) {
+        statements.push(this.parseVariable());
+      } else if (token.kind === 0 /* Keyword */ && token.value === "class") {
+        statements.push(this.parseClass());
+      } else if (token.kind === 0 /* Keyword */ && token.value === "delete") {
+        statements.push(this.parseDelete());
+      } else if (token.kind === 0 /* Keyword */ && token.value === "enum") {
+        statements.push(this.parseEnum());
+      } else {
+        const token2 = this.peek();
+        if (token2) {
+          throw new Error(`${this.filename}:${token2.line}:${token2.column}: Unexpected token: ${TokenKind[token2.kind]} '${token2.value}'`);
+        } else {
+          throw new Error(`${this.filename}: Unexpected end of input`);
+        }
+      }
+    }
+    return {
+      kind: "document",
+      statements
+    };
+  }
+};
+
+// src/preprocessor.ts
+var readFileSync;
+var resolve;
+if (typeof process !== "undefined" && process.versions?.node) {
+  try {
+    const fs = __require("fs");
+    const path = __require("path");
+    readFileSync = fs.readFileSync;
+    resolve = path.resolve;
+  } catch {
+  }
+}
+var Preprocessor = class {
+  constructor(options = {}) {
+    this.defines = new Map(options.defines ?? []);
+    this.conditionStack = [];
+    this.skipLines = false;
+    this.processedFiles = /* @__PURE__ */ new Set();
+    this.includePaths = options.includePaths ?? [];
+  }
+  preprocess(filePath) {
+    if (!readFileSync) {
+      throw new Error("Preprocessor.preprocess() requires Node.js file system access");
+    }
+    const input = readFileSync(filePath, "utf8");
+    const lines = input.split("\n");
+    const output = [];
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (line.startsWith("#")) {
+        const directive = this.parseDirective(line);
+        if (!directive) {
+          continue;
+        }
+        this.processDirective(directive, output, filePath);
+      } else {
+        if (!this.skipLines) {
+          let processedLine = line;
+          for (const [key, value] of this.defines) {
+            processedLine = processedLine.replace(new RegExp(`\\b${key}\\b`, "g"), value);
+          }
+          output.push(processedLine);
+        }
+      }
+    }
+    return output.join("\n");
+  }
+  processDirective(directive, output, currentFile) {
+    switch (directive.type) {
+      case "define":
+        if (!this.skipLines) {
+          this.defines.set(directive.name, directive.value ?? "");
+        }
+        break;
+      case "undef":
+        if (!this.skipLines) {
+          this.defines.delete(directive.name);
+        }
+        break;
+      case "ifdef":
+        this.conditionStack.push(this.skipLines);
+        this.skipLines = this.skipLines || !this.defines.has(directive.name);
+        break;
+      case "ifndef":
+        this.conditionStack.push(this.skipLines);
+        this.skipLines = this.skipLines || this.defines.has(directive.name);
+        break;
+      case "else":
+        if (this.conditionStack.length > 0) {
+          this.skipLines = !this.skipLines;
+        }
+        break;
+      case "endif":
+        if (this.conditionStack.length > 0) {
+          this.skipLines = this.conditionStack.pop();
+        }
+        break;
+      case "include":
+        if (!this.skipLines && directive.file) {
+          if (!resolve) {
+            console.warn("#include directive ignored in browser environment");
+            break;
+          }
+          const fullPath = currentFile ? resolve(currentFile, "..", directive.file) : directive.file;
+          if (this.processedFiles.has(fullPath)) {
+            console.warn(`Recursive include detected for ${directive.file}, skipping`);
+          } else {
+            try {
+              this.processedFiles.add(fullPath);
+              const includedContent = this.loadAndPreprocessFile(directive.file, currentFile);
+              output.push(includedContent);
+            } catch (error) {
+              console.error(`Failed to include ${directive.file}: `, error);
+            }
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  }
+  parseDirective(line) {
+    const parts = line.split(/\s+/);
+    if (parts.length === 0) {
+      return null;
+    }
+    const type = parts[0].substring(1);
+    switch (type) {
+      case "define":
+        if (parts.length >= 2) {
+          const name = parts[1];
+          const value = parts.slice(2).join(" ");
+          return { type: "define", name, value };
+        }
+        break;
+      case "undef":
+        if (parts.length >= 2) {
+          return { type: "undef", name: parts[1] };
+        }
+        break;
+      case "ifdef":
+      case "ifndef":
+        if (parts.length >= 2) {
+          return { type, name: parts[1] };
+        }
+        break;
+      case "else":
+        return { type: "else" };
+      case "endif":
+        return { type: "endif" };
+      case "include":
+        const includeMatch = /^#include\s+["<]([^">]+)[">]$/.exec(line);
+        if (includeMatch) {
+          const file = includeMatch[1];
+          const isQuoted = line.includes('"');
+          if (isQuoted) {
+            return { type: "include", file };
+          }
+        }
+        break;
+    }
+    return null;
+  }
+  loadAndPreprocessFile(includePath, currentFile) {
+    if (!resolve || !readFileSync) {
+      throw new Error("#include requires Node.js file system access");
+    }
+    let fullPath;
+    if (currentFile) {
+      fullPath = resolve(currentFile, "..", includePath);
+    } else {
+      fullPath = includePath;
+      for (const includePath2 of this.includePaths) {
+        const candidate = resolve(includePath2, includePath2);
+        try {
+          readFileSync(candidate, "utf8");
+          fullPath = candidate;
+          break;
+        } catch {
+        }
+      }
+    }
+    return this.preprocess(fullPath);
+  }
+};
+
+// src/RvmatParser.ts
+var RvmatParser = class {
+  /**
+   * Parse RVMAT file content
+   */
+  static parse(content, filename = "<rvmat>") {
+    const parser = new Parser(content, filename);
+    const document = parser.parse();
+    const data = { stages: [] };
+    data.ambient = this.readNumberArray(this.findVariable(document, "ambient"));
+    data.diffuse = this.readNumberArray(this.findVariable(document, "diffuse"));
+    data.forcedDiffuse = this.readNumberArray(this.findVariable(document, "forcedDiffuse"));
+    data.emmisive = this.readNumberArray(this.findVariable(document, "emmisive"));
+    data.specular = this.readNumberArray(this.findVariable(document, "specular"));
+    data.specularPower = this.readNumber(this.findVariable(document, "specularPower"));
+    data.pixelShaderID = this.readString(this.findVariable(document, "PixelShaderID"));
+    data.vertexShaderID = this.readString(this.findVariable(document, "VertexShaderID"));
+    this.extractStages(document, data);
+    return data;
+  }
+  static findVariable(document, name) {
+    const target = name.toLowerCase();
+    for (let i = document.statements.length - 1; i >= 0; i--) {
+      const statement = document.statements[i];
+      if (this.isVariable(statement) && statement.name.toLowerCase() === target) {
+        return statement;
+      }
+    }
+    return void 0;
+  }
+  static extractStages(document, data) {
+    const collectFromClass = (cls) => {
+      if (/^stage\d+$/i.test(cls.name)) {
+        const textureProp = this.findClassProperty(cls, "texture");
+        if (textureProp && this.isSimpleVariable(textureProp)) {
+          const texture = this.readString(textureProp);
+          if (texture && texture.trim() !== "") {
+            data.stages.push({ name: cls.name, texture });
+          }
+        }
+      }
+      for (const property of cls.properties.values()) {
+        if (this.isClass(property)) {
+          collectFromClass(property);
+        }
+      }
+    };
+    for (const statement of document.statements) {
+      if (this.isClass(statement)) {
+        collectFromClass(statement);
+      }
+    }
+  }
+  static findClassProperty(cls, propertyName) {
+    const target = propertyName.toLowerCase();
+    let match;
+    for (const [name, property] of cls.properties) {
+      if (name.toLowerCase() === target) {
+        match = property;
+      }
+    }
+    return match;
+  }
+  static readNumberArray(node) {
+    if (!node) {
+      return void 0;
+    }
+    const raw = node.kind === "array" ? node.values : node.value;
+    if (!Array.isArray(raw)) {
+      return void 0;
+    }
+    const numbers = raw.map((value) => this.toNumber(value)).filter((value) => value !== void 0);
+    return numbers.length > 0 ? numbers : void 0;
+  }
+  static readNumber(node) {
+    if (!node) {
+      return void 0;
+    }
+    if (node.kind === "variable") {
+      return this.toNumber(node.value);
+    }
+    return node.values.length === 1 ? this.toNumber(node.values[0]) : void 0;
+  }
+  static readString(node) {
+    if (!node || !this.isSimpleVariable(node)) {
+      return void 0;
+    }
+    const value = node.value;
+    return typeof value === "string" ? value : void 0;
+  }
+  static toNumber(value) {
+    if (typeof value === "number") {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = parseFloat(value);
+      return Number.isFinite(parsed) ? parsed : void 0;
+    }
+    return void 0;
+  }
+  static isVariable(node) {
+    return node.kind === "variable" || node.kind === "array";
+  }
+  static isSimpleVariable(node) {
+    return node.kind === "variable";
+  }
+  static isClass(node) {
+    return node.kind === "class";
+  }
+  /**
+   * Get all texture paths from parsed data
+   */
+  static getTexturePaths(data) {
+    return data.stages.map((stage) => stage.texture);
+  }
+  /**
+   * Get main diffuse/color texture (typically Stage1)
+   */
+  static getMainTexture(data) {
+    return data.stages.find((s) => s.name === "Stage1")?.texture;
+  }
+};
+export {
+  CfgKeywords,
+  CfgOperators,
+  CfgPunctuations,
+  Parser,
+  Preprocessor,
+  RvmatParser,
+  TokenKind,
+  isCfgKeyword,
+  isCfgPunctuation,
+  lex
+};
+//# sourceMappingURL=index.js.map