typed-csv 1.0.0

package/dist/index.js

@@ -0,0 +1,877 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ParseError: () => ParseError,
+  createValidator: () => createValidator,
+  defineSchema: () => defineSchema,
+  parseSchema: () => parseSchema,
+  parseValue: () => parseValue,
+  schemaToTypeString: () => schemaToTypeString
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/index.ts
+function defineSchema(schemaString) {
+  const schema = parseSchema(schemaString);
+  const validator = createValidator(schema);
+  return {
+    schema,
+    validator,
+    parse: (valueString) => parseValue(schema, valueString)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParseError,
+  createValidator,
+  defineSchema,
+  parseSchema,
+  parseValue,
+  schemaToTypeString
+});