typed-csv 1.0.0

package/dist/csv-loader/webpack.js

@@ -0,0 +1,1979 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/csv-loader/webpack.ts
+var webpack_exports = {};
+__export(webpack_exports, {
+  default: () => csvLoader
+});
+module.exports = __toCommonJS(webpack_exports);
+var path4 = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+
+// src/csv-loader/module-gen.ts
+var path3 = __toESM(require("path"));
+
+// src/csv-loader/loader.ts
+var import_sync = require("csv-parse/sync");
+
+// src/parser.ts
+var ParseError = class extends Error {
+  constructor(message, position, schema, value) {
+    let fullMessage = message;
+    if (position !== void 0) {
+      fullMessage += ` at position ${position}`;
+    }
+    if (schema !== void 0) {
+      fullMessage += `. Schema: ${schema}`;
+    }
+    if (value !== void 0) {
+      fullMessage += `. Value: ${value}`;
+    }
+    super(fullMessage);
+    this.position = position;
+    this.schema = schema;
+    this.value = value;
+    this.name = "ParseError";
+  }
+};
+var Parser = class {
+  constructor(input) {
+    this.pos = 0;
+    this.input = input;
+  }
+  peek() {
+    return this.input[this.pos] || "";
+  }
+  consume() {
+    return this.input[this.pos++] || "";
+  }
+  skipWhitespace() {
+    while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
+      this.pos++;
+    }
+  }
+  match(str) {
+    return this.input.slice(this.pos, this.pos + str.length) === str;
+  }
+  consumeStr(str) {
+    if (this.match(str)) {
+      this.pos += str.length;
+      return true;
+    }
+    return false;
+  }
+  getPosition() {
+    return this.pos;
+  }
+  getInputLength() {
+    return this.input.length;
+  }
+  parseSchema() {
+    this.skipWhitespace();
+    let schema = this.parseSchemaInternal();
+    this.skipWhitespace();
+    if (this.consumeStr("[")) {
+      this.skipWhitespace();
+      if (!this.consumeStr("]")) {
+        throw new ParseError("Expected ]", this.pos);
+      }
+      schema = { type: "array", element: schema };
+      this.skipWhitespace();
+    }
+    if (this.consumeStr("|")) {
+      const members = [schema];
+      while (true) {
+        this.skipWhitespace();
+        const member = this.parseSchemaInternal();
+        members.push(member);
+        this.skipWhitespace();
+        if (!this.consumeStr("|")) {
+          break;
+        }
+      }
+      return {
+        type: "union",
+        members
+      };
+    }
+    return schema;
+  }
+  parseSchemaInternal() {
+    this.skipWhitespace();
+    if (this.consumeStr("(")) {
+      this.skipWhitespace();
+      const schema = this.parseSchema();
+      this.skipWhitespace();
+      if (!this.consumeStr(")")) {
+        throw new ParseError("Expected )", this.pos);
+      }
+      this.skipWhitespace();
+      if (this.consumeStr("[")) {
+        this.skipWhitespace();
+        if (!this.consumeStr("]")) {
+          throw new ParseError("Expected ]", this.pos);
+        }
+        return { type: "array", element: schema };
+      }
+      return schema;
+    }
+    if (this.peek() === '"' || this.peek() === "'") {
+      return this.parseStringLiteralSchema();
+    }
+    if (this.consumeStr("~")) {
+      return this.parseReverseReferenceSchema();
+    }
+    if (this.consumeStr("@")) {
+      return this.parseReferenceSchema();
+    }
+    if (this.consumeStr("string")) {
+      if (this.consumeStr("[")) {
+        this.skipWhitespace();
+        if (!this.consumeStr("]")) {
+          throw new ParseError("Expected ]", this.pos);
+        }
+        return { type: "array", element: { type: "string" } };
+      }
+      return { type: "string" };
+    }
+    if (this.consumeStr("number")) {
+      if (this.consumeStr("[")) {
+        this.skipWhitespace();
+        if (!this.consumeStr("]")) {
+          throw new ParseError("Expected ]", this.pos);
+        }
+        return { type: "array", element: { type: "number" } };
+      }
+      return { type: "number" };
+    }
+    if (this.consumeStr("int")) {
+      if (this.consumeStr("[")) {
+        this.skipWhitespace();
+        if (!this.consumeStr("]")) {
+          throw new ParseError("Expected ]", this.pos);
+        }
+        return { type: "array", element: { type: "int" } };
+      }
+      return { type: "int" };
+    }
+    if (this.consumeStr("float")) {
+      if (this.consumeStr("[")) {
+        this.skipWhitespace();
+        if (!this.consumeStr("]")) {
+          throw new ParseError("Expected ]", this.pos);
+        }
+        return { type: "array", element: { type: "float" } };
+      }
+      return { type: "float" };
+    }
+    if (this.consumeStr("boolean")) {
+      if (this.consumeStr("[")) {
+        this.skipWhitespace();
+        if (!this.consumeStr("]")) {
+          throw new ParseError("Expected ]", this.pos);
+        }
+        return { type: "array", element: { type: "boolean" } };
+      }
+      return { type: "boolean" };
+    }
+    if (this.consumeStr("[")) {
+      const elements = [];
+      this.skipWhitespace();
+      if (this.peek() === "]") {
+        this.consume();
+        throw new ParseError("Empty array/tuple not allowed", this.pos);
+      }
+      elements.push(this.parseNamedSchema());
+      this.skipWhitespace();
+      if (this.consumeStr(";")) {
+        const remainingElements = [];
+        while (true) {
+          this.skipWhitespace();
+          remainingElements.push(this.parseNamedSchema());
+          this.skipWhitespace();
+          if (!this.consumeStr(";")) {
+            break;
+          }
+        }
+        elements.push(...remainingElements);
+      }
+      this.skipWhitespace();
+      if (!this.consumeStr("]")) {
+        throw new ParseError("Expected ]", this.pos);
+      }
+      if (this.consumeStr("[")) {
+        this.skipWhitespace();
+        if (!this.consumeStr("]")) {
+          throw new ParseError("Expected ]", this.pos);
+        }
+        if (elements.length === 1 && !elements[0].name) {
+          return { type: "array", element: elements[0].schema };
+        }
+        return { type: "array", element: { type: "tuple", elements } };
+      }
+      if (elements.length === 1 && !elements[0].name) {
+        return { type: "array", element: elements[0].schema };
+      }
+      return { type: "tuple", elements };
+    }
+    throw new ParseError(
+      `Unknown type: ${this.peek() || "end of input"}`,
+      this.pos
+    );
+  }
+  parseStringLiteralSchema() {
+    const value = this.parseStringLiteral();
+    return {
+      type: "stringLiteral",
+      value
+    };
+  }
+  parseStringLiteral() {
+    const quote = this.peek();
+    if (quote !== '"' && quote !== "'") {
+      throw new ParseError("Expected string literal with quotes", this.pos);
+    }
+    this.consume();
+    let value = "";
+    while (this.pos < this.input.length) {
+      const char = this.peek();
+      if (char === "\\") {
+        this.consume();
+        const nextChar = this.consume();
+        if (nextChar === '"' || nextChar === "'" || nextChar === "\\" || nextChar === "|" || nextChar === ";" || nextChar === "(" || nextChar === ")") {
+          value += nextChar;
+        } else {
+          value += "\\" + nextChar;
+        }
+      } else if (char === quote) {
+        this.consume();
+        return value;
+      } else {
+        value += this.consume();
+      }
+    }
+    throw new ParseError("Unterminated string literal", this.pos);
+  }
+  parseNamedSchema() {
+    this.skipWhitespace();
+    const startpos = this.pos;
+    let identifier = "";
+    while (this.pos < this.input.length && /[a-zA-Z0-9\-_]/.test(this.peek())) {
+      identifier += this.consume();
+    }
+    if (identifier.length === 0) {
+      const schema = this.parseSchema();
+      return { schema };
+    }
+    this.skipWhitespace();
+    if (this.consumeStr(":")) {
+      this.skipWhitespace();
+      const name = identifier;
+      const schema = this.parseSchema();
+      return { name, schema };
+    } else {
+      this.pos = startpos;
+      const schema = this.parseSchema();
+      return { schema };
+    }
+  }
+  parseReferenceSchema() {
+    let tableName = "";
+    while (this.pos < this.input.length && /[a-zA-Z0-9\-_]/.test(this.peek())) {
+      tableName += this.consume();
+    }
+    if (tableName.length === 0) {
+      throw new ParseError("Expected table name after @", this.pos);
+    }
+    this.skipWhitespace();
+    if (this.consumeStr("[]")) {
+      this.skipWhitespace();
+      const isOptional2 = this.consumeStr("?");
+      return {
+        type: "reference",
+        tableName,
+        isArray: true,
+        isOptional: isOptional2
+      };
+    }
+    const isOptional = this.consumeStr("?");
+    return {
+      type: "reference",
+      tableName,
+      isArray: false,
+      isOptional
+    };
+  }
+  parseReverseReferenceSchema() {
+    let tableName = "";
+    while (this.pos < this.input.length && /[a-zA-Z0-9\-_]/.test(this.peek())) {
+      tableName += this.consume();
+    }
+    if (tableName.length === 0) {
+      throw new ParseError("Expected table name after ~", this.pos);
+    }
+    this.skipWhitespace();
+    if (!this.consumeStr("(")) {
+      throw new ParseError(
+        "Expected ( after reverse reference table name",
+        this.pos
+      );
+    }
+    this.skipWhitespace();
+    let foreignKey = "";
+    while (this.pos < this.input.length && /[a-zA-Z0-9\-_]/.test(this.peek())) {
+      foreignKey += this.consume();
+    }
+    if (foreignKey.length === 0) {
+      throw new ParseError("Expected foreign key name inside ()", this.pos);
+    }
+    this.skipWhitespace();
+    if (!this.consumeStr(")")) {
+      throw new ParseError("Expected ) after foreign key name", this.pos);
+    }
+    this.skipWhitespace();
+    const isOptional = this.consumeStr("?");
+    return {
+      type: "reverseReference",
+      tableName,
+      foreignKey,
+      isOptional
+    };
+  }
+};
+function parseSchema(schemaString) {
+  const parser = new Parser(schemaString.trim());
+  const schema = parser.parseSchema();
+  if (parser.getPosition() < parser.getInputLength()) {
+    throw new ParseError("Unexpected input after schema", parser.getPosition());
+  }
+  return schema;
+}
+
+// src/type-utils.ts
+function schemaToTypeString(schema, resourceNames) {
+  switch (schema.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "int":
+    case "float":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "stringLiteral":
+      return `"${schema.value}"`;
+    case "union":
+      return schema.members.map((m) => schemaToTypeString(m, resourceNames)).join(" | ");
+    case "reference": {
+      const typeName = resourceNames?.get(schema.tableName) || schema.tableName.charAt(0).toUpperCase() + schema.tableName.slice(1);
+      const baseType = schema.isArray ? `${typeName}[]` : typeName;
+      return schema.isOptional ? `${baseType} | null` : baseType;
+    }
+    case "reverseReference": {
+      const typeName = resourceNames?.get(schema.tableName) || schema.tableName.charAt(0).toUpperCase() + schema.tableName.slice(1);
+      const baseType = `${typeName}[]`;
+      return schema.isOptional ? `${baseType} | null` : baseType;
+    }
+    case "array":
+      if (schema.element.type === "tuple") {
+        const tupleElements2 = schema.element.elements.map((el) => {
+          const typeStr = schemaToTypeString(el.schema, resourceNames);
+          return el.name ? `${el.name}: ${typeStr}` : typeStr;
+        });
+        return `[${tupleElements2.join(", ")}][]`;
+      }
+      const elementType = schemaToTypeString(schema.element, resourceNames);
+      if (schema.element.type === "union") {
+        return `(${elementType})[]`;
+      }
+      return `${elementType}[]`;
+    case "tuple":
+      const tupleElements = schema.elements.map((el) => {
+        const typeStr = schemaToTypeString(el.schema, resourceNames);
+        return el.name ? `${el.name}: ${typeStr}` : typeStr;
+      });
+      return `[${tupleElements.join(", ")}]`;
+    default:
+      return "unknown";
+  }
+}
+function createValidator(schema) {
+  return function validate(value) {
+    switch (schema.type) {
+      case "string":
+        return typeof value === "string";
+      case "number":
+        return typeof value === "number" && !isNaN(value);
+      case "int":
+        return typeof value === "number" && !isNaN(value) && Number.isInteger(value);
+      case "float":
+        return typeof value === "number" && !isNaN(value);
+      case "boolean":
+        return typeof value === "boolean";
+      case "stringLiteral":
+        return typeof value === "string" && value === schema.value;
+      case "union":
+        return schema.members.some((member) => createValidator(member)(value));
+      case "tuple":
+        if (!Array.isArray(value)) return false;
+        if (value.length !== schema.elements.length) return false;
+        return schema.elements.every(
+          (elementSchema, index) => createValidator(elementSchema.schema)(value[index])
+        );
+      case "array":
+        if (!Array.isArray(value)) return false;
+        return value.every((item) => createValidator(schema.element)(item));
+      case "reference":
+        if (schema.isOptional && value === null) return true;
+        if (schema.isArray) {
+          return Array.isArray(value) && value.every((id) => typeof id === "string");
+        }
+        return typeof value === "string" || Array.isArray(value) && value.every((id) => typeof id === "string");
+      case "reverseReference":
+        if (schema.isOptional && value === null) return true;
+        return Array.isArray(value);
+      default:
+        return false;
+    }
+  };
+}
+
+// src/value-parser.ts
+var ValueParser = class {
+  constructor(input, schemaString) {
+    this.pos = 0;
+    this.input = input;
+    this.schemaString = schemaString;
+  }
+  peek() {
+    return this.input[this.pos] || "";
+  }
+  consume() {
+    return this.input[this.pos++] || "";
+  }
+  skipWhitespace() {
+    while (this.pos < this.input.length && /\s/.test(this.input[this.pos])) {
+      this.pos++;
+    }
+  }
+  consumeStr(str) {
+    if (this.input.slice(this.pos, this.pos + str.length) === str) {
+      this.pos += str.length;
+      return true;
+    }
+    return false;
+  }
+  parseValue(schema, allowOmitBrackets = false) {
+    this.skipWhitespace();
+    switch (schema.type) {
+      case "string":
+        return this.parseStringValue();
+      case "number":
+        return this.parseNumberValue();
+      case "int":
+        return this.parseIntValue();
+      case "float":
+        return this.parseFloatValue();
+      case "boolean":
+        return this.parseBooleanValue();
+      case "stringLiteral":
+        return this.parseStringLiteralValue(schema);
+      case "union":
+        return this.parseUnionValue(schema);
+      case "tuple":
+        return this.parseTupleValue(schema, allowOmitBrackets);
+      case "array":
+        return this.parseArrayValue(schema, allowOmitBrackets);
+      case "reference":
+        return this.parseReferenceValue(schema);
+      case "reverseReference":
+        return null;
+      default:
+        throw new ParseError(
+          `Unknown schema type: ${schema.type}`,
+          this.pos,
+          this.schemaString,
+          this.input
+        );
+    }
+  }
+  parseStringValue() {
+    let result = "";
+    while (this.pos < this.input.length) {
+      const char = this.peek();
+      if (char === "\\") {
+        this.consume();
+        const nextChar = this.consume();
+        if (nextChar === ";" || nextChar === "[" || nextChar === "]" || nextChar === "\\") {
+          result += nextChar;
+        } else {
+          result += "\\" + nextChar;
+        }
+      } else if (char === ";" || char === "]") {
+        break;
+      } else {
+        result += this.consume();
+      }
+    }
+    return result.trim();
+  }
+  parseNumberValue() {
+    let numStr = "";
+    while (this.pos < this.input.length && /[\d.\-+eE]/.test(this.peek())) {
+      numStr += this.consume();
+    }
+    const num = parseFloat(numStr);
+    if (isNaN(num)) {
+      throw new ParseError(
+        "Invalid number",
+        this.pos - numStr.length,
+        this.schemaString,
+        this.input
+      );
+    }
+    return num;
+  }
+  parseIntValue() {
+    let numStr = "";
+    while (this.pos < this.input.length && /[\d.\-+eE]/.test(this.peek())) {
+      numStr += this.consume();
+    }
+    const num = parseFloat(numStr);
+    if (isNaN(num)) {
+      throw new ParseError(
+        "Invalid number",
+        this.pos - numStr.length,
+        this.schemaString,
+        this.input
+      );
+    }
+    if (!Number.isInteger(num)) {
+      throw new ParseError(
+        "Expected integer value",
+        this.pos - numStr.length,
+        this.schemaString,
+        this.input
+      );
+    }
+    return num;
+  }
+  parseFloatValue() {
+    return this.parseNumberValue();
+  }
+  parseBooleanValue() {
+    if (this.consumeStr("true")) {
+      return true;
+    }
+    if (this.consumeStr("false")) {
+      return false;
+    }
+    throw new ParseError(
+      "Expected true or false",
+      this.pos,
+      this.schemaString,
+      this.input
+    );
+  }
+  parseStringLiteralValue(schema) {
+    const quote = this.peek();
+    if (quote === '"' || quote === "'") {
+      this.consume();
+      let value = "";
+      while (this.pos < this.input.length) {
+        const char = this.peek();
+        if (char === "\\") {
+          this.consume();
+          const nextChar = this.consume();
+          if (nextChar === '"' || nextChar === "'" || nextChar === "\\" || nextChar === ";") {
+            value += nextChar;
+          } else {
+            value += "\\" + nextChar;
+          }
+        } else if (char === quote) {
+          this.consume();
+          if (value !== schema.value) {
+            throw new ParseError(
+              `Invalid value '"${value}"'. Expected '"${schema.value}"'`,
+              this.pos,
+              this.schemaString,
+              this.input
+            );
+          }
+          return value;
+        } else {
+          value += this.consume();
+        }
+      }
+      throw new ParseError(
+        "Unterminated string literal",
+        this.pos,
+        this.schemaString,
+        this.input
+      );
+    } else {
+      let value = "";
+      while (this.pos < this.input.length) {
+        const char = this.peek();
+        if (char === ";" || char === "]" || char === ")") {
+          break;
+        }
+        value += this.consume();
+      }
+      value = value.trim();
+      if (value !== schema.value) {
+        throw new ParseError(
+          `Invalid value '${value}'. Expected '${schema.value}'`,
+          this.pos - value.length,
+          this.schemaString,
+          this.input
+        );
+      }
+      return value;
+    }
+  }
+  parseUnionValue(schema) {
+    const savedPos = this.pos;
+    const errors = [];
+    for (let i = 0; i < schema.members.length; i++) {
+      this.pos = savedPos;
+      try {
+        return this.parseValue(schema.members[i], false);
+      } catch (e) {
+        errors.push(e);
+      }
+    }
+    throw new ParseError(
+      `Value does not match any union member. Tried ${schema.members.length} alternatives.`,
+      this.pos,
+      this.schemaString,
+      this.input
+    );
+  }
+  parseTupleValue(schema, allowOmitBrackets) {
+    let hasOpenBracket = false;
+    if (this.peek() === "[") {
+      this.consume();
+      hasOpenBracket = true;
+    } else if (!allowOmitBrackets) {
+      throw new ParseError(
+        "Expected [",
+        this.pos,
+        this.schemaString,
+        this.input
+      );
+    }
+    this.skipWhitespace();
+    if (this.peek() === "]" && hasOpenBracket) {
+      this.consume();
+      return [];
+    }
+    const result = [];
+    for (let i = 0; i < schema.elements.length; i++) {
+      this.skipWhitespace();
+      const elementSchema = schema.elements[i];
+      if (elementSchema.name) {
+        this.skipWhitespace();
+        const savedPos = this.pos;
+        if (this.consumeStr(`${elementSchema.name}:`)) {
+          this.skipWhitespace();
+        } else {
+          this.pos = savedPos;
+        }
+      }
+      result.push(this.parseValue(elementSchema.schema, false));
+      this.skipWhitespace();
+      if (i < schema.elements.length - 1) {
+        if (!this.consumeStr(";")) {
+          throw new ParseError(
+            "Expected ;",
+            this.pos,
+            this.schemaString,
+            this.input
+          );
+        }
+      }
+    }
+    this.skipWhitespace();
+    if (hasOpenBracket) {
+      if (!this.consumeStr("]")) {
+        throw new ParseError(
+          "Expected ]",
+          this.pos,
+          this.schemaString,
+          this.input
+        );
+      }
+    }
+    return result;
+  }
+  parseArrayValue(schema, allowOmitBrackets) {
+    let hasOpenBracket = false;
+    const elementIsTupleOrArray = schema.element.type === "tuple" || schema.element.type === "array";
+    if (this.pos >= this.input.length || !this.input.trim()) {
+      return [];
+    }
+    if (this.peek() === "[") {
+      if (!elementIsTupleOrArray) {
+        this.consume();
+        hasOpenBracket = true;
+      } else {
+        const savedPos = this.pos;
+        this.consume();
+        this.skipWhitespace();
+        if (this.peek() === "]") {
+          this.consume();
+          return [];
+        } else if (this.peek() === "[") {
+          hasOpenBracket = true;
+        } else {
+          this.pos = savedPos;
+        }
+      }
+    }
+    if (!hasOpenBracket && !allowOmitBrackets && !elementIsTupleOrArray) {
+      throw new ParseError(
+        "Expected [",
+        this.pos,
+        this.schemaString,
+        this.input
+      );
+    }
+    this.skipWhitespace();
+    if (this.peek() === "]" && hasOpenBracket) {
+      this.consume();
+      return [];
+    }
+    const result = [];
+    while (true) {
+      this.skipWhitespace();
+      result.push(this.parseValue(schema.element, elementIsTupleOrArray));
+      this.skipWhitespace();
+      if (!this.consumeStr(";")) {
+        break;
+      }
+    }
+    this.skipWhitespace();
+    if (hasOpenBracket) {
+      if (!this.consumeStr("]")) {
+        throw new ParseError(
+          "Expected ]",
+          this.pos,
+          this.schemaString,
+          this.input
+        );
+      }
+    }
+    return result;
+  }
+  parseReferenceValue(schema) {
+    if (schema.isOptional) {
+      this.skipWhitespace();
+      if (this.pos >= this.input.length) {
+        return null;
+      }
+    }
+    if (schema.isArray) {
+      let hasOpenBracket = false;
+      if (this.peek() === "[") {
+        this.consume();
+        hasOpenBracket = true;
+      }
+      this.skipWhitespace();
+      if (this.peek() === "]" && hasOpenBracket) {
+        this.consume();
+        return [];
+      }
+      const ids = [];
+      while (true) {
+        this.skipWhitespace();
+        let id = "";
+        while (this.pos < this.input.length && this.peek() !== ";" && this.peek() !== "]") {
+          id += this.consume();
+        }
+        ids.push(id.trim());
+        this.skipWhitespace();
+        if (!this.consumeStr(";")) {
+          break;
+        }
+      }
+      if (hasOpenBracket) {
+        if (!this.consumeStr("]")) {
+          throw new ParseError(
+            "Expected ]",
+            this.pos,
+            this.schemaString,
+            this.input
+          );
+        }
+      }
+      return ids;
+    } else {
+      let id = "";
+      while (this.pos < this.input.length) {
+        const char = this.peek();
+        if (char === ";" || char === "]" || char === ",") {
+          break;
+        }
+        id += this.consume();
+      }
+      return id.trim();
+    }
+  }
+  getPosition() {
+    return this.pos;
+  }
+  getInputLength() {
+    return this.input.length;
+  }
+};
+function parseValue(schema, valueString, schemaString) {
+  const sStr = schemaString || schemaToTypeString(schema);
+  const parser = new ValueParser(valueString.trim(), sStr);
+  const allowOmitBrackets = schema.type === "tuple" || schema.type === "array";
+  const value = parser.parseValue(schema, allowOmitBrackets);
+  if (parser.getPosition() < parser.getInputLength()) {
+    throw new ParseError(
+      "Unexpected input after value",
+      parser.getPosition(),
+      sStr,
+      valueString.trim()
+    );
+  }
+  return value;
+}
+
+// src/csv-loader/reference-resolver.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var referenceTableCache = /* @__PURE__ */ new Map();
+var loadingFiles = /* @__PURE__ */ new Set();
+function hasNestedReferences(schema) {
+  switch (schema.type) {
+    case "reference":
+    case "reverseReference":
+      return true;
+    case "tuple":
+      return schema.elements.some((el) => hasNestedReferences(el.schema));
+    case "array":
+      return hasNestedReferences(schema.element);
+    case "union":
+      return schema.members.some((m) => hasNestedReferences(m));
+    default:
+      return false;
+  }
+}
+function loadReferenceTable(schema, refBaseDir, defaultPrimaryKey, currentFilePath) {
+  const baseDir = refBaseDir || (currentFilePath ? path.dirname(currentFilePath) : process.cwd());
+  const fileName = `${schema.tableName}.csv`;
+  const refFilePath = path.isAbsolute(fileName) ? fileName : path.join(baseDir, fileName);
+  let refTable;
+  if (referenceTableCache.has(refFilePath)) {
+    refTable = referenceTableCache.get(refFilePath);
+  } else {
+    if (loadingFiles.has(refFilePath)) {
+      throw new Error(
+        `Circular reference detected: table "${schema.tableName}" (${refFilePath}) is already being loaded`
+      );
+    }
+    loadingFiles.add(refFilePath);
+    try {
+      const refContent = fs.readFileSync(refFilePath, "utf-8");
+      const refResult = parseCsv(refContent, {
+        currentFilePath: refFilePath,
+        emitTypes: false
+      });
+      refTable = refResult.data;
+      referenceTableCache.set(refFilePath, refTable);
+    } catch (error) {
+      throw new Error(
+        `Failed to load referenced table "${schema.tableName}" from ${refFilePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    } finally {
+      loadingFiles.delete(refFilePath);
+    }
+  }
+  const lookup = /* @__PURE__ */ new Map();
+  refTable.forEach((row) => {
+    const pkValue = row[defaultPrimaryKey];
+    if (pkValue !== void 0) {
+      lookup.set(String(pkValue), row);
+    }
+  });
+  return { lookup, refTable };
+}
+function resolveReferenceId(id, lookup, tableName) {
+  const obj = lookup.get(id);
+  if (!obj) {
+    throw new Error(`Reference to "${tableName}" with id="${id}" not found`);
+  }
+  return obj;
+}
+function parseReferenceIds(schema, valueString) {
+  const trimmed = valueString.trim();
+  if (schema.isOptional && trimmed === "") {
+    return null;
+  }
+  return parseValue(schema, trimmed);
+}
+function parseValueWithReferenceIds(valueString, schema) {
+  if (!hasNestedReferences(schema)) {
+    return parseValue(schema, valueString);
+  }
+  switch (schema.type) {
+    case "reference":
+      return parseReferenceIds(schema, valueString);
+    case "reverseReference":
+      return null;
+    case "tuple": {
+      const parsed = parseValue(schema, valueString);
+      return schema.elements.map(
+        (el, i) => hasNestedReferences(el.schema) ? extractNestedReferenceIds(parsed[i], el.schema) : parsed[i]
+      );
+    }
+    case "array": {
+      const parsed = parseValue(schema, valueString);
+      return parsed.map(
+        (item) => hasNestedReferences(schema.element) ? extractNestedReferenceIds(item, schema.element) : item
+      );
+    }
+    case "union": {
+      for (const member of schema.members) {
+        if (hasNestedReferences(member)) {
+          try {
+            const parsed = parseValue(member, valueString);
+            return extractNestedReferenceIds(parsed, member);
+          } catch {
+          }
+        }
+      }
+      return parseValue(schema, valueString);
+    }
+    default:
+      return parseValue(schema, valueString);
+  }
+}
+function extractNestedReferenceIds(value, schema) {
+  switch (schema.type) {
+    case "reference":
+      if (value === null || value === void 0) return value;
+      if (schema.isArray) {
+        const ids = Array.isArray(value) ? value : [value];
+        return ids.map((id) => String(id));
+      }
+      return String(value);
+    case "reverseReference":
+      return null;
+    case "tuple": {
+      if (!Array.isArray(value)) return value;
+      return schema.elements.map(
+        (el, i) => hasNestedReferences(el.schema) ? extractNestedReferenceIds(value[i], el.schema) : value[i]
+      );
+    }
+    case "array": {
+      if (!Array.isArray(value)) return value;
+      return value.map(
+        (item) => hasNestedReferences(schema.element) ? extractNestedReferenceIds(item, schema.element) : item
+      );
+    }
+    case "union": {
+      for (const member of schema.members) {
+        if (hasNestedReferences(member)) {
+          try {
+            return extractNestedReferenceIds(value, member);
+          } catch {
+          }
+        }
+      }
+      return value;
+    }
+    default:
+      return value;
+  }
+}
+function collectReferenceFields(schema, name) {
+  const fields = [];
+  switch (schema.type) {
+    case "reference":
+      fields.push({
+        name,
+        tableName: schema.tableName,
+        isArray: schema.isArray,
+        schema
+      });
+      break;
+    case "reverseReference":
+      fields.push({
+        name,
+        tableName: schema.tableName,
+        isArray: true,
+        foreignKey: schema.foreignKey,
+        schema
+      });
+      break;
+    case "tuple":
+      for (const el of schema.elements) {
+        fields.push(...collectReferenceFields(el.schema, name));
+      }
+      break;
+    case "array":
+      fields.push(...collectReferenceFields(schema.element, name));
+      break;
+    case "union":
+      for (const member of schema.members) {
+        fields.push(...collectReferenceFields(member, name));
+      }
+      break;
+  }
+  return fields;
+}
+function parseValueWithReferences(valueString, schema, refBaseDir, defaultPrimaryKey, currentFilePath, currentRowPk) {
+  if (!hasNestedReferences(schema)) {
+    return parseValue(schema, valueString);
+  }
+  switch (schema.type) {
+    case "reference":
+      return parseReferenceValue(
+        schema,
+        valueString,
+        refBaseDir,
+        defaultPrimaryKey,
+        currentFilePath
+      );
+    case "reverseReference": {
+      if (currentRowPk === void 0) return [];
+      return resolveReverseReference(
+        schema,
+        currentRowPk,
+        refBaseDir,
+        defaultPrimaryKey,
+        currentFilePath
+      );
+    }
+    case "tuple": {
+      const parsed = parseValue(schema, valueString);
+      return schema.elements.map(
+        (el, i) => resolveNestedReferences(
+          parsed[i],
+          el.schema,
+          refBaseDir,
+          defaultPrimaryKey,
+          currentFilePath,
+          currentRowPk
+        )
+      );
+    }
+    case "array": {
+      const parsed = parseValue(schema, valueString);
+      return parsed.map(
+        (item) => resolveNestedReferences(
+          item,
+          schema.element,
+          refBaseDir,
+          defaultPrimaryKey,
+          currentFilePath,
+          currentRowPk
+        )
+      );
+    }
+    case "union": {
+      const errors = [];
+      for (const member of schema.members) {
+        if (hasNestedReferences(member)) {
+          try {
+            const parsed = parseValue(member, valueString);
+            return resolveNestedReferences(
+              parsed,
+              member,
+              refBaseDir,
+              defaultPrimaryKey,
+              currentFilePath,
+              currentRowPk
+            );
+          } catch (e) {
+            errors.push(e instanceof Error ? e : new Error(String(e)));
+          }
+        }
+      }
+      if (errors.length > 0 && errors.every(
+        (e) => /not found|Circular reference|Failed to load/.test(e.message)
+      )) {
+        for (const member of schema.members) {
+          if (!hasNestedReferences(member)) {
+            try {
+              return parseValue(member, valueString);
+            } catch {
+            }
+          }
+        }
+      }
+      return parseValue(schema, valueString);
+    }
+    default:
+      return parseValue(schema, valueString);
+  }
+}
+function resolveReverseReference(schema, pkValue, refBaseDir, defaultPrimaryKey, currentFilePath) {
+  const { refTable } = loadReferenceTable(
+    schema,
+    refBaseDir,
+    defaultPrimaryKey,
+    currentFilePath
+  );
+  const pkStr = String(pkValue);
+  return refTable.filter((row) => {
+    const fkValue = row[schema.foreignKey];
+    const fkStr = fkValue !== null && fkValue !== void 0 && typeof fkValue === "object" ? String(fkValue[defaultPrimaryKey]) : String(fkValue);
+    return fkStr === pkStr;
+  });
+}
+function resolveNestedReferences(value, schema, refBaseDir, defaultPrimaryKey, currentFilePath, currentRowPk) {
+  switch (schema.type) {
+    case "reference": {
+      if (value === null || value === void 0) return value;
+      const { lookup } = loadReferenceTable(
+        schema,
+        refBaseDir,
+        defaultPrimaryKey,
+        currentFilePath
+      );
+      if (schema.isArray) {
+        const ids = Array.isArray(value) ? value : [value];
+        return ids.map(
+          (id) => resolveReferenceId(String(id), lookup, schema.tableName)
+        );
+      }
+      return resolveReferenceId(String(value), lookup, schema.tableName);
+    }
+    case "reverseReference": {
+      if (currentRowPk === void 0) return [];
+      const results = resolveReverseReference(
+        schema,
+        currentRowPk,
+        refBaseDir,
+        defaultPrimaryKey,
+        currentFilePath
+      );
+      return results;
+    }
+    case "tuple": {
+      if (!Array.isArray(value)) return value;
+      return schema.elements.map(
+        (el, i) => resolveNestedReferences(
+          value[i],
+          el.schema,
+          refBaseDir,
+          defaultPrimaryKey,
+          currentFilePath,
+          currentRowPk
+        )
+      );
+    }
+    case "array": {
+      if (!Array.isArray(value)) return value;
+      return value.map(
+        (item) => resolveNestedReferences(
+          item,
+          schema.element,
+          refBaseDir,
+          defaultPrimaryKey,
+          currentFilePath,
+          currentRowPk
+        )
+      );
+    }
+    case "union": {
+      const errors = [];
+      for (const member of schema.members) {
+        if (hasNestedReferences(member)) {
+          try {
+            return resolveNestedReferences(
+              value,
+              member,
+              refBaseDir,
+              defaultPrimaryKey,
+              currentFilePath,
+              currentRowPk
+            );
+          } catch (e) {
+            errors.push(e instanceof Error ? e : new Error(String(e)));
+          }
+        }
+      }
+      if (errors.length > 0) {
+        throw errors[0];
+      }
+      return value;
+    }
+    default:
+      return value;
+  }
+}
+function parseReferenceValue(schema, valueString, refBaseDir, defaultPrimaryKey, currentFilePath) {
+  const trimmed = valueString.trim();
+  if (schema.isOptional && trimmed === "") {
+    return null;
+  }
+  const { lookup } = loadReferenceTable(
+    schema,
+    refBaseDir,
+    defaultPrimaryKey,
+    currentFilePath
+  );
+  const ids = parseValue(schema, trimmed);
+  if (ids === null) return null;
+  if (schema.isArray && Array.isArray(ids)) {
+    return ids.map((id) => resolveReferenceId(id, lookup, schema.tableName));
+  }
+  return resolveReferenceId(ids, lookup, schema.tableName);
+}
+
+// src/csv-loader/type-gen.ts
+var path2 = __toESM(require("path"));
+function resolveReferencesInSchemaString(schemaString, resourceNames) {
+  return schemaString.replace(/@([a-zA-Z0-9\-_]+)(\[\])?/g, (_match, tableName, arraySuffix) => {
+    const typeName = resourceNames.get(tableName) || tableName.charAt(0).toUpperCase() + tableName.slice(1);
+    return arraySuffix ? `${typeName}[]` : typeName;
+  }).replace(/; ?/g, ", ");
+}
+function generateTypeDefinition(resourceName, propertyConfigs, references, currentFilePath, typeDeclarations = []) {
+  const typeName = resourceName ? `${resourceName}Table` : "Table";
+  const currentTableName = currentFilePath ? path2.basename(currentFilePath, path2.extname(currentFilePath)) : void 0;
+  const singularType = resourceName ? resourceName.charAt(0).toUpperCase() + resourceName.slice(1) : `${typeName}[number]`;
+  const imports = [];
+  const resourceNames = /* @__PURE__ */ new Map();
+  references.forEach((tableName) => {
+    if (tableName === currentTableName) {
+      resourceNames.set(tableName, singularType);
+      return;
+    }
+    const typeBase = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+    resourceNames.set(tableName, typeBase);
+    let importPath;
+    if (currentFilePath) {
+      importPath = `./${tableName}.csv`;
+    } else {
+      importPath = `../${tableName}.csv`;
+    }
+    imports.push(`import type { ${typeBase} } from '${importPath}';`);
+  });
+  const importSection = imports.length > 0 ? imports.join("\n") + "\n\n" : "";
+  const typeDeclarationSection = typeDeclarations.length > 0 ? typeDeclarations.map(
+    (decl) => `export type ${decl.name} = ${decl.schemaString ? resolveReferencesInSchemaString(decl.schemaString, resourceNames) : schemaToTypeString(decl.schema, resourceNames)};`
+  ).join("\n") + "\n\n" : "";
+  const properties = propertyConfigs.map((config) => {
+    const typeStr = config.declaredTypeName ? config.declaredTypeName : config.schemaString ? resolveReferencesInSchemaString(config.schemaString, resourceNames) : schemaToTypeString(config.schema, resourceNames);
+    return `    readonly ${config.name}: ${typeStr};`;
+  }).join("\n");
+  let exportAlias = "";
+  if (resourceName) {
+    const singularType2 = resourceName.charAt(0).toUpperCase() + resourceName.slice(1);
+    exportAlias = `
+export type ${singularType2} = ${typeName}[number];`;
+  }
+  return `${importSection}${typeDeclarationSection}type ${typeName} = readonly {
+${properties}
+}[];
+${exportAlias}
+
+declare function getData(): ${typeName};
+export default getData;
+`;
+}
+
+// src/csv-loader/type-declarations.ts
+function parseTypeDeclaration(line, commentChar = "#") {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith(commentChar)) return null;
+  const content = trimmed.slice(commentChar.length).trim();
+  const match = content.match(/^type\s+([A-Z][a-zA-Z0-9]*)\s*=\s*(.+)$/);
+  if (!match) return null;
+  const [, typeName, schemaString] = match;
+  return { typeName, schemaString };
+}
+function expandTypeName(schemaString, declaredTypes) {
+  const trimmed = schemaString.trim();
+  if (declaredTypes.has(trimmed)) {
+    return declaredTypes.get(trimmed);
+  }
+  return null;
+}
+function expandSchemaString(schemaString, declaredTypes) {
+  let result = schemaString;
+  let prev = "";
+  while (prev !== result) {
+    prev = result;
+    result = expandSchemaInString(result, declaredTypes);
+  }
+  return result;
+}
+function expandSchemaInString(schemaString, declaredTypes) {
+  const expanded = expandTypeName(schemaString.trim(), declaredTypes);
+  if (expanded !== null) {
+    return expanded;
+  }
+  const trimmed = schemaString.trim();
+  if (trimmed.endsWith("[]")) {
+    const inner = trimmed.slice(0, -2);
+    const expandedInner = expandSchemaInString(inner, declaredTypes);
+    return `${expandedInner}[]`;
+  }
+  if (schemaString.includes("|")) {
+    const parts = splitByToken(schemaString, "|");
+    if (parts.length > 1) {
+      const expandedParts = parts.map(
+        (part) => expandSchemaInString(part.trim(), declaredTypes)
+      );
+      return expandedParts.join(" | ");
+    }
+  }
+  if (schemaString.startsWith("[") && schemaString.endsWith("]")) {
+    const inner = schemaString.slice(1, -1);
+    if (inner.includes(";")) {
+      const elements = splitByToken(inner, ";");
+      const expandedElements = elements.map(
+        (el) => expandSchemaInString(el.trim(), declaredTypes)
+      );
+      return `[${expandedElements.join("; ")}]`;
+    }
+    return `[${expandSchemaInString(inner, declaredTypes)}]`;
+  }
+  const typeNameMatch = schemaString.trim().match(/^[A-Z][a-zA-Z0-9]*$/);
+  if (typeNameMatch) {
+    const expanded2 = expandTypeName(schemaString.trim(), declaredTypes);
+    if (expanded2 !== null) {
+      return expanded2;
+    }
+  }
+  return schemaString;
+}
+function splitByToken(str, token) {
+  const result = [];
+  let current = "";
+  let inQuote = null;
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    if (inQuote) {
+      if (char === inQuote && str[i - 1] !== "\\") {
+        inQuote = null;
+      }
+      current += char;
+    } else if (char === '"' || char === "'") {
+      inQuote = char;
+      current += char;
+    } else if (char === token && inQuote === null) {
+      result.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.length > 0 || str.endsWith(token)) {
+    result.push(current);
+  }
+  return result;
+}
+function resolveTypeReferences(schema, declaredTypes) {
+  switch (schema.type) {
+    case "union":
+      return {
+        type: "union",
+        members: schema.members.map(
+          (m) => resolveTypeReferences(m, declaredTypes)
+        )
+      };
+    case "tuple":
+      return {
+        type: "tuple",
+        elements: schema.elements.map((el) => ({
+          name: el.name,
+          schema: resolveTypeReferences(el.schema, declaredTypes)
+        }))
+      };
+    case "array":
+      return {
+        type: "array",
+        element: resolveTypeReferences(schema.element, declaredTypes)
+      };
+    case "reference":
+      return schema;
+    default:
+      return schema;
+  }
+}
+function parseReverseReferenceDeclaration(line, commentChar = "#") {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith(commentChar)) return null;
+  const content = trimmed.slice(commentChar.length).trim();
+  const match = content.match(/^inject\s+(\w+)\s*=\s*~(\w+)\((\w+)\)(\?)?$/);
+  if (!match) return null;
+  const [, fieldName, tableName, foreignKey, optionalMark] = match;
+  const isOptional = optionalMark === "?";
+  const schema = {
+    type: "reverseReference",
+    tableName,
+    foreignKey,
+    isOptional
+  };
+  return {
+    fieldName,
+    tableName,
+    foreignKey,
+    isOptional,
+    schema
+  };
+}
+
+// src/csv-loader/loader.ts
+function parseCsv(content, options = {}) {
+  const delimiter = options.delimiter ?? ",";
+  const quote = options.quote ?? '"';
+  const escape = options.escape ?? "\\";
+  const bom = options.bom ?? true;
+  const comment = options.comment === false ? void 0 : options.comment ?? "#";
+  const trim = options.trim ?? true;
+  const emitTypes = options.emitTypes ?? true;
+  const refBaseDir = options.refBaseDir;
+  const defaultPrimaryKey = options.defaultPrimaryKey ?? "id";
+  const reverseReferences = [];
+  const typeDeclarationsRaw = [];
+  let filteredContent = content;
+  if (comment) {
+    const lines = content.split(/\r?\n/);
+    const nonCommentLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith(comment)) {
+        const typeDecl = parseTypeDeclaration(trimmed, comment);
+        if (typeDecl) {
+          typeDeclarationsRaw.push(typeDecl);
+          continue;
+        }
+        const decl = parseReverseReferenceDeclaration(trimmed, comment);
+        if (decl) {
+          reverseReferences.push(decl);
+          continue;
+        }
+        continue;
+      }
+      nonCommentLines.push(line);
+    }
+    filteredContent = nonCommentLines.join("\n");
+  }
+  const records = (0, import_sync.parse)(filteredContent, {
+    delimiter,
+    quote,
+    escape,
+    bom,
+    comment: void 0,
+    trim,
+    skip_empty_lines: true,
+    relax_column_count: true
+  });
+  const filteredRecords = records;
+  if (filteredRecords.length < 2) {
+    throw new Error("CSV must have at least 2 rows: headers and schemas");
+  }
+  const headers = filteredRecords[0];
+  const schemas = filteredRecords[1];
+  if (headers.length !== schemas.length) {
+    throw new Error(
+      `Header count (${headers.length}) does not match schema count (${schemas.length})`
+    );
+  }
+  const dataRows = filteredRecords.slice(2);
+  for (let col = 0; col < schemas.length; col++) {
+    const cell = (schemas[col] ?? "").trim();
+    if (comment && cell.startsWith(comment)) {
+      const typeDecl = parseTypeDeclaration(cell, comment);
+      if (typeDecl) {
+        typeDeclarationsRaw.push(typeDecl);
+        continue;
+      }
+      const decl = parseReverseReferenceDeclaration(cell, comment);
+      if (decl) {
+        reverseReferences.push(decl);
+      }
+    }
+  }
+  const declaredTypeNames = /* @__PURE__ */ new Set();
+  for (const decl of typeDeclarationsRaw) {
+    declaredTypeNames.add(decl.typeName);
+  }
+  const declaredSchemaStrings = /* @__PURE__ */ new Map();
+  for (const decl of typeDeclarationsRaw) {
+    declaredSchemaStrings.set(decl.typeName, decl.schemaString);
+  }
+  const typeDeclarationsParsed = [];
+  for (const decl of typeDeclarationsRaw) {
+    const expandedSchema = expandSchemaString(
+      decl.schemaString,
+      declaredSchemaStrings
+    );
+    const schema = parseSchema(expandedSchema.trim());
+    typeDeclarationsParsed.push({
+      name: decl.typeName,
+      schema,
+      schemaString: decl.schemaString
+    });
+  }
+  const declaredTypes = /* @__PURE__ */ new Map();
+  for (const decl of typeDeclarationsParsed) {
+    declaredTypes.set(decl.name, decl.schema);
+  }
+  const typeDeclarations = [];
+  for (const decl of typeDeclarationsParsed) {
+    const resolvedSchema = resolveTypeReferences(decl.schema, declaredTypes);
+    typeDeclarations.push({
+      name: decl.name,
+      schema: resolvedSchema,
+      schemaString: decl.schemaString
+    });
+  }
+  for (const decl of typeDeclarations) {
+    declaredTypes.set(decl.name, decl.schema);
+  }
+  const resolveReferences = options.resolveReferences ?? true;
+  const propertyConfigs = headers.map(
+    (header, index) => {
+      const schemaString = schemas[index];
+      let schema;
+      let declaredTypeName;
+      let columnSchemaString;
+      if (declaredTypes.has(schemaString)) {
+        schema = declaredTypes.get(schemaString);
+        declaredTypeName = schemaString;
+      } else {
+        const expandedSchema = expandSchemaString(
+          schemaString,
+          declaredSchemaStrings
+        );
+        schema = parseSchema(expandedSchema.trim());
+        if (expandedSchema !== schemaString) {
+          columnSchemaString = schemaString;
+        }
+      }
+      const config = {
+        name: header,
+        schema,
+        validator: createValidator(schema),
+        parser: (valueString) => parseValue(schema, valueString),
+        declaredTypeName,
+        schemaString: columnSchemaString
+      };
+      if (schema.type === "reference") {
+        config.isReference = true;
+        config.referenceTableName = schema.tableName;
+        config.referenceIsArray = schema.isArray;
+        if (resolveReferences) {
+          config.parser = (valueString) => {
+            return parseReferenceValue(
+              schema,
+              valueString,
+              refBaseDir,
+              defaultPrimaryKey,
+              options.currentFilePath
+            );
+          };
+        } else {
+          config.parser = (valueString) => {
+            return parseReferenceIds(schema, valueString);
+          };
+        }
+      } else if (hasNestedReferences(schema)) {
+        config.isReference = true;
+        if (resolveReferences) {
+          config.parser = (valueString) => {
+            return parseValueWithReferences(
+              valueString,
+              schema,
+              refBaseDir,
+              defaultPrimaryKey,
+              options.currentFilePath
+            );
+          };
+        } else {
+          config.parser = (valueString) => {
+            return parseValueWithReferenceIds(valueString, schema);
+          };
+        }
+      }
+      return config;
+    }
+  );
+  for (const decl of reverseReferences) {
+    const config = {
+      name: decl.fieldName,
+      schema: decl.schema,
+      validator: createValidator(decl.schema),
+      parser: (_valueString) => {
+        return null;
+      },
+      isReference: true,
+      isReverseReference: true,
+      referenceTableName: decl.tableName,
+      referenceIsArray: true,
+      reverseReferenceForeignKey: decl.foreignKey
+    };
+    propertyConfigs.push(config);
+  }
+  const references = /* @__PURE__ */ new Set();
+  function collectReferences(schema) {
+    if (schema.type === "reference") {
+      references.add(schema.tableName);
+    } else if (schema.type === "reverseReference") {
+      references.add(schema.tableName);
+    } else if (schema.type === "tuple") {
+      schema.elements.forEach((el) => collectReferences(el.schema));
+    } else if (schema.type === "array") {
+      collectReferences(schema.element);
+    } else if (schema.type === "union") {
+      schema.members.forEach((m) => collectReferences(m));
+    }
+  }
+  propertyConfigs.forEach((config) => {
+    if (config.isReference && config.referenceTableName) {
+      references.add(config.referenceTableName);
+    }
+    collectReferences(config.schema);
+  });
+  const objects = dataRows.map((row, rowIndex) => {
+    const obj = {};
+    propertyConfigs.forEach((config, colIndex) => {
+      if (config.isReverseReference) {
+        return;
+      }
+      const rawValue = row[colIndex] ?? "";
+      try {
+        const parsed = config.parser(rawValue);
+        if (!config.isReference && !config.validator(parsed)) {
+          throw new Error(
+            `Validation failed for property "${config.name}" at row ${rowIndex + 3}: ${rawValue}`
+          );
+        }
+        obj[config.name] = parsed;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(
+            `Failed to parse property "${config.name}" at row ${rowIndex + 3}, column ${colIndex + 1}: ${error.message}`
+          );
+        }
+        throw error;
+      }
+    });
+    return obj;
+  });
+  if (resolveReferences) {
+    for (const decl of reverseReferences) {
+      for (const obj of objects) {
+        const pkValue = obj[defaultPrimaryKey];
+        if (pkValue !== void 0) {
+          const resolved = resolveReverseReference(
+            decl.schema,
+            pkValue,
+            refBaseDir,
+            defaultPrimaryKey,
+            options.currentFilePath
+          );
+          obj[decl.fieldName] = decl.isOptional && resolved.length === 0 ? null : resolved;
+        } else {
+          obj[decl.fieldName] = decl.isOptional ? null : [];
+        }
+      }
+    }
+  }
+  const referenceFields = [];
+  if (!resolveReferences) {
+    for (const config of propertyConfigs) {
+      if (hasNestedReferences(config.schema)) {
+        referenceFields.push(
+          ...collectReferenceFields(config.schema, config.name)
+        );
+      }
+    }
+  }
+  const result = {
+    data: objects,
+    propertyConfigs,
+    references,
+    referenceFields,
+    reverseReferences,
+    typeDeclarations
+  };
+  if (emitTypes) {
+    result.typeDefinition = generateTypeDefinition(
+      options.resourceName || "",
+      propertyConfigs,
+      references,
+      options.currentFilePath,
+      typeDeclarations
+    );
+  }
+  return result;
+}
+
+// src/csv-loader/module-gen.ts
+function generateSchemaResolutionCode(schema, valueExpr, lookupVar, pkField, reverseLookupVar) {
+  switch (schema.type) {
+    case "reference": {
+      const lookup = lookupVar(schema.tableName);
+      if (schema.isOptional) {
+        if (schema.isArray) {
+          return `(${valueExpr} === null || ${valueExpr} === undefined ? ${valueExpr} : (Array.isArray(${valueExpr}) ? ${valueExpr}.map(id => ${lookup}.get(String(id))) : ${lookup}.get(String(${valueExpr}))))`;
+        }
+        return `(${valueExpr} === null || ${valueExpr} === undefined ? ${valueExpr} : ${lookup}.get(String(${valueExpr})))`;
+      }
+      if (schema.isArray) {
+        return `(Array.isArray(${valueExpr}) ? ${valueExpr}.map(id => ${lookup}.get(String(id))) : ${valueExpr})`;
+      }
+      return `${lookup}.get(String(${valueExpr}))`;
+    }
+    case "reverseReference": {
+      if (!reverseLookupVar) return valueExpr;
+      const reverseLookup = reverseLookupVar(
+        schema.tableName,
+        schema.foreignKey
+      );
+      if (schema.isOptional) {
+        return `(${reverseLookup}.get(String(row.${pkField})) || null)`;
+      }
+      return `(${reverseLookup}.get(String(row.${pkField})) || [])`;
+    }
+    case "tuple": {
+      const elementResolvers = schema.elements.map((el, i) => {
+        if (hasNestedReferences(el.schema)) {
+          return generateSchemaResolutionCode(
+            el.schema,
+            `${valueExpr}[${i}]`,
+            lookupVar,
+            pkField,
+            reverseLookupVar
+          );
+        }
+        return `${valueExpr}[${i}]`;
+      });
+      return `[${elementResolvers.join(", ")}]`;
+    }
+    case "array": {
+      if (hasNestedReferences(schema.element)) {
+        const itemResolve = generateSchemaResolutionCode(
+          schema.element,
+          "item",
+          lookupVar,
+          pkField,
+          reverseLookupVar
+        );
+        return `(${valueExpr}).map(item => ${itemResolve})`;
+      }
+      return valueExpr;
+    }
+    case "union": {
+      const refMembers = schema.members.filter((m) => hasNestedReferences(m));
+      const nonRefMembers = schema.members.filter(
+        (m) => !hasNestedReferences(m)
+      );
+      const resolveParts = [];
+      for (const member of refMembers) {
+        const resolveCode = generateSchemaResolutionCode(
+          member,
+          valueExpr,
+          lookupVar,
+          pkField,
+          reverseLookupVar
+        );
+        resolveParts.push(resolveCode);
+      }
+      if (nonRefMembers.length > 0) {
+        resolveParts.push(valueExpr);
+      }
+      if (resolveParts.length === 0) return valueExpr;
+      if (resolveParts.length === 1) return resolveParts[0];
+      return `(${resolveParts.join(" ?? ")})`;
+    }
+    default:
+      return valueExpr;
+  }
+}
+function csvToModule(content, options = {}) {
+  const result = parseCsv(content, { ...options, resolveReferences: false });
+  const hasRefs = result.referenceFields.length > 0 || result.reverseReferences.length > 0;
+  const defaultPrimaryKey = options.defaultPrimaryKey ?? "id";
+  const imports = [];
+  const lookupInits = [];
+  const lookupVarMap = /* @__PURE__ */ new Map();
+  const reverseLookupInits = [];
+  const reverseLookupVarMap = /* @__PURE__ */ new Map();
+  const currentTableName = options.currentFilePath ? path3.basename(
+    options.currentFilePath,
+    path3.extname(options.currentFilePath)
+  ) : void 0;
+  const uniqueTables = new Set(result.referenceFields.map((f) => f.tableName));
+  for (const decl of result.reverseReferences) {
+    uniqueTables.add(decl.tableName);
+  }
+  uniqueTables.forEach((tableName) => {
+    const lookupVar2 = `_${tableName}Lookup`;
+    lookupVarMap.set(tableName, lookupVar2);
+    if (tableName === currentTableName) {
+      lookupInits.push(
+        `const ${lookupVar2} = new Map(_raw.map(p => [String(p.${defaultPrimaryKey}), p]));`
+      );
+    } else {
+      const varName = `_${tableName}`;
+      imports.push(`import ${varName} from './${tableName}.csv';`);
+      lookupInits.push(
+        `const ${lookupVar2} = new Map(${varName}().map(p => [String(p.${defaultPrimaryKey}), p]));`
+      );
+    }
+  });
+  for (const decl of result.reverseReferences) {
+    const key = `${decl.tableName}:${decl.foreignKey}`;
+    if (reverseLookupVarMap.has(key)) continue;
+    const revLookupVar = `_${decl.tableName}By_${decl.foreignKey}`;
+    reverseLookupVarMap.set(key, revLookupVar);
+    if (decl.tableName === currentTableName) {
+      reverseLookupInits.push(
+        `const ${revLookupVar} = new Map();`,
+        `for (const r of _raw) {`,
+        `  const kv = r.${decl.foreignKey};`,
+        `  const k = String(typeof kv === "object" && "${defaultPrimaryKey}" in kv ? kv.${defaultPrimaryKey} : kv);`,
+        `  if (!${revLookupVar}.has(k)) ${revLookupVar}.set(k, []);`,
+        `  ${revLookupVar}.get(k).push(r);`,
+        `}`
+      );
+    } else {
+      const varName = `_${decl.tableName}`;
+      reverseLookupInits.push(
+        `const ${revLookupVar} = new Map();`,
+        `for (const r of ${varName}()) {`,
+        `  const kv = r.${decl.foreignKey};`,
+        `  const k = String(typeof kv === "object" && "${defaultPrimaryKey}" in kv ? kv.${defaultPrimaryKey} : kv);`,
+        `  if (!${revLookupVar}.has(k)) ${revLookupVar}.set(k, []);`,
+        `  ${revLookupVar}.get(k).push(r);`,
+        `}`
+      );
+    }
+  }
+  const lookupVar = (tableName) => lookupVarMap.get(tableName);
+  const reverseLookupVar = (tableName, foreignKey) => reverseLookupVarMap.get(`${tableName}:${foreignKey}`);
+  const rowResolvers = [];
+  for (const config of result.propertyConfigs) {
+    if (config.isReverseReference) {
+      const decl = result.reverseReferences.find(
+        (d) => d.fieldName === config.name
+      );
+      if (decl) {
+        const revLookup = reverseLookupVar(decl.tableName, decl.foreignKey);
+        if (decl.isOptional) {
+          rowResolvers.push({
+            name: config.name,
+            code: `(${revLookup}.get(String(row.${defaultPrimaryKey})) || null)`
+          });
+        } else {
+          rowResolvers.push({
+            name: config.name,
+            code: `(${revLookup}.get(String(row.${defaultPrimaryKey})) || [])`
+          });
+        }
+      }
+    } else if (hasNestedReferences(config.schema)) {
+      const resolveCode = generateSchemaResolutionCode(
+        config.schema,
+        `row.${config.name}`,
+        lookupVar,
+        defaultPrimaryKey,
+        reverseLookupVar
+      );
+      rowResolvers.push({ name: config.name, code: resolveCode });
+    }
+  }
+  const rawJson = JSON.stringify(result.data, null, 2);
+  const js = [
+    ...imports,
+    "",
+    `const _raw = ${rawJson};`,
+    "",
+    "let _resolved = null;",
+    "",
+    "export default function getData() {",
+    "  if (_resolved) return _resolved;",
+    "  _resolved = _raw;",
+    ...lookupInits.map((l) => `  ${l}`),
+    ...reverseLookupInits.map((l) => `  ${l}`),
+    ...rowResolvers.length > 0 ? [
+      "  _resolved = _raw.map(row => {",
+      ...rowResolvers.map((r) => `    row.${r.name} = ${r.code};`),
+      "    return row;",
+      "  });"
+    ] : [],
+    "  return _resolved;",
+    "}"
+  ].join("\n");
+  return {
+    js,
+    dts: result.typeDefinition
+  };
+}
+
+// src/csv-loader/webpack.ts
+function csvLoader(content) {
+  const options = this.getOptions();
+  const emitTypes = options?.emitTypes ?? true;
+  const typesOutputDir = options?.typesOutputDir ?? "";
+  const writeToDisk = options?.writeToDisk ?? false;
+  const fileName = path4.basename(this.resourcePath, ".csv").split(".")[0];
+  const resourceName = fileName.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^(.)/, (_, char) => char.toUpperCase());
+  const result = csvToModule(content, {
+    ...options,
+    resourceName,
+    currentFilePath: this.resourcePath
+  });
+  if (emitTypes && result.dts) {
+    const context = this.context || "";
+    let relativePath = this.resourcePath.replace(context, "");
+    if (relativePath.startsWith("\\") || relativePath.startsWith("/")) {
+      relativePath = relativePath.substring(1);
+    }
+    relativePath = relativePath.replace(/\\/g, "/");
+    const dtsFileName = `${relativePath}.d.ts`;
+    const outputPath = typesOutputDir ? path4.join(typesOutputDir, dtsFileName) : dtsFileName;
+    if (writeToDisk) {
+      const absolutePath = path4.join(
+        this.context || process.cwd(),
+        typesOutputDir || "",
+        dtsFileName
+      );
+      fs2.mkdirSync(path4.dirname(absolutePath), { recursive: true });
+      fs2.writeFileSync(absolutePath, result.dts);
+    } else {
+      this.emitFile?.(outputPath, result.dts);
+    }
+  }
+  return result.js;
+}