@utilix-tech/sdk 0.1.0

package/dist/tools/json.cjs

@@ -0,0 +1,1270 @@
+'use strict';
+
+var yaml = require('js-yaml');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var yaml__namespace = /*#__PURE__*/_interopNamespace(yaml);
+
+// src/tools/json.ts
+function parseJson(input, indent) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return { status: "idle", output: "", error: null, lines: 0, bytes: 0 };
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    const output = indent === null ? JSON.stringify(parsed) : JSON.stringify(parsed, null, indent);
+    return {
+      status: "valid",
+      output,
+      error: null,
+      lines: output.split("\n").length,
+      bytes: Buffer.byteLength(output, "utf8")
+    };
+  } catch (e) {
+    return {
+      status: "error",
+      output: trimmed,
+      error: e.message,
+      lines: 0,
+      bytes: 0
+    };
+  }
+}
+function minifyJson(input) {
+  if (input.trim() === "") return { error: "Input is empty" };
+  try {
+    return JSON.stringify(JSON.parse(input));
+  } catch {
+    return { error: "Invalid JSON" };
+  }
+}
+function formatJson(input, indent = 2) {
+  if (input.trim() === "") return { error: "Input is empty" };
+  try {
+    return JSON.stringify(JSON.parse(input), null, indent);
+  } catch {
+    return { error: "Invalid JSON" };
+  }
+}
+function getJsonStats(input) {
+  if (input.trim() === "") return { error: "Input is empty" };
+  try {
+    const minified = JSON.stringify(JSON.parse(input));
+    const originalSize = Buffer.byteLength(input, "utf8");
+    const minifiedSize = Buffer.byteLength(minified, "utf8");
+    const savingPercent = originalSize === 0 ? 0 : Math.round((originalSize - minifiedSize) / originalSize * 1e4) / 100;
+    return { originalSize, minifiedSize, savingPercent };
+  } catch {
+    return { error: "Invalid JSON" };
+  }
+}
+function _isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function _isArray(value) {
+  return Array.isArray(value);
+}
+function _diffValues(left, right, path, counts) {
+  if (_isObject(left) && _isObject(right)) {
+    const children = _diffObjects(left, right, path, counts);
+    const allUnchanged = children.every((c) => c.type === "unchanged");
+    return { type: allUnchanged ? "unchanged" : "changed", path, children };
+  }
+  if (_isArray(left) && _isArray(right)) {
+    const children = _diffArrays(left, right, path, counts);
+    const allUnchanged = children.every((c) => c.type === "unchanged");
+    return { type: allUnchanged ? "unchanged" : "changed", path, children };
+  }
+  if (JSON.stringify(left) === JSON.stringify(right)) {
+    return { type: "unchanged", path, leftValue: left, rightValue: right };
+  }
+  counts.changed++;
+  return { type: "changed", path, leftValue: left, rightValue: right };
+}
+function _diffObjects(left, right, basePath, counts) {
+  const nodes = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)]);
+  for (const key of allKeys) {
+    const childPath = `${basePath}.${key}`;
+    const inLeft = Object.prototype.hasOwnProperty.call(left, key);
+    const inRight = Object.prototype.hasOwnProperty.call(right, key);
+    if (inLeft && !inRight) {
+      counts.removed++;
+      nodes.push({ type: "removed", path: childPath, leftValue: left[key] });
+    } else if (!inLeft && inRight) {
+      counts.added++;
+      nodes.push({ type: "added", path: childPath, rightValue: right[key] });
+    } else {
+      nodes.push(_diffValues(left[key], right[key], childPath, counts));
+    }
+  }
+  return nodes;
+}
+function _diffArrays(left, right, basePath, counts) {
+  const nodes = [];
+  const maxLen = Math.max(left.length, right.length);
+  for (let i = 0; i < maxLen; i++) {
+    const childPath = `${basePath}[${i}]`;
+    const inLeft = i < left.length;
+    const inRight = i < right.length;
+    if (inLeft && !inRight) {
+      counts.removed++;
+      nodes.push({ type: "removed", path: childPath, leftValue: left[i] });
+    } else if (!inLeft && inRight) {
+      counts.added++;
+      nodes.push({ type: "added", path: childPath, rightValue: right[i] });
+    } else {
+      nodes.push(_diffValues(left[i], right[i], childPath, counts));
+    }
+  }
+  return nodes;
+}
+function diffJson(left, right) {
+  let leftVal;
+  let rightVal;
+  try {
+    leftVal = JSON.parse(left);
+  } catch {
+    return { error: "Invalid JSON in left input" };
+  }
+  try {
+    rightVal = JSON.parse(right);
+  } catch {
+    return { error: "Invalid JSON in right input" };
+  }
+  const counts = { added: 0, removed: 0, changed: 0 };
+  let nodes;
+  if (_isObject(leftVal) && _isObject(rightVal)) {
+    nodes = _diffObjects(leftVal, rightVal, "$", counts);
+  } else if (_isArray(leftVal) && _isArray(rightVal)) {
+    nodes = _diffArrays(leftVal, rightVal, "$", counts);
+  } else {
+    const node = _diffValues(leftVal, rightVal, "$", counts);
+    nodes = [node];
+  }
+  const unchanged = counts.added === 0 && counts.removed === 0 && counts.changed === 0;
+  return {
+    nodes,
+    addedCount: counts.added,
+    removedCount: counts.removed,
+    changedCount: counts.changed,
+    unchanged
+  };
+}
+function formatDiffLine(node) {
+  switch (node.type) {
+    case "added":
+      return `+ ${node.path}: ${JSON.stringify(node.rightValue)}`;
+    case "removed":
+      return `- ${node.path}: ${JSON.stringify(node.leftValue)}`;
+    case "changed":
+      if (node.children) {
+        return `~ ${node.path}`;
+      }
+      return `~ ${node.path}: ${JSON.stringify(node.leftValue)} \u2192 ${JSON.stringify(node.rightValue)}`;
+    case "unchanged":
+      return `  ${node.path}: ${JSON.stringify(node.leftValue ?? node.rightValue)}`;
+  }
+}
+function _escapeField(value, delimiter) {
+  const needsQuoting = value.includes(delimiter) || value.includes("\n") || value.includes("\r") || value.includes('"');
+  if (needsQuoting) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function _valueToString(value, nullAs) {
+  if (value === null || value === void 0) return nullAs;
+  if (typeof value === "boolean") return value.toString();
+  if (typeof value === "number") return value.toString();
+  return String(value);
+}
+function jsonToCsv(json, options) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return { error: "Invalid JSON input" };
+  }
+  if (!Array.isArray(parsed)) {
+    return { error: "Input must be a JSON array" };
+  }
+  const delimiter = options?.delimiter ?? ",";
+  const includeHeaders = options?.includeHeaders ?? true;
+  const nullAs = options?.nullAs ?? "";
+  if (parsed.length === 0) {
+    return "";
+  }
+  const allPrimitives = parsed.every(
+    (item) => item === null || typeof item !== "object"
+  );
+  if (allPrimitives) {
+    const rows2 = [];
+    if (includeHeaders) {
+      rows2.push(_escapeField("value", delimiter));
+    }
+    for (const item of parsed) {
+      rows2.push(_escapeField(_valueToString(item, nullAs), delimiter));
+    }
+    return rows2.join("\n");
+  }
+  const keySet = /* @__PURE__ */ new Set();
+  for (const item of parsed) {
+    if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+      for (const key of Object.keys(item)) {
+        keySet.add(key);
+      }
+    }
+  }
+  const headers = [...keySet];
+  const rows = [];
+  if (includeHeaders) {
+    rows.push(headers.map((h) => _escapeField(h, delimiter)).join(delimiter));
+  }
+  for (const item of parsed) {
+    if (item === null || typeof item !== "object" || Array.isArray(item)) {
+      rows.push(headers.map(() => _escapeField(nullAs, delimiter)).join(delimiter));
+      continue;
+    }
+    const obj = item;
+    const cells = headers.map((h) => {
+      const val = Object.prototype.hasOwnProperty.call(obj, h) ? obj[h] : void 0;
+      return _escapeField(_valueToString(val, nullAs), delimiter);
+    });
+    rows.push(cells.join(delimiter));
+  }
+  return rows.join("\n");
+}
+function _parseRow(line, delimiter) {
+  const fields = [];
+  let i = 0;
+  while (i <= line.length) {
+    if (i === line.length) {
+      if (line[line.length - 1] === delimiter) {
+        fields.push("");
+      }
+      break;
+    }
+    if (line[i] === '"') {
+      let field = "";
+      i++;
+      while (i < line.length) {
+        if (line[i] === '"') {
+          if (line[i + 1] === '"') {
+            field += '"';
+            i += 2;
+          } else {
+            i++;
+            break;
+          }
+        } else {
+          field += line[i];
+          i++;
+        }
+      }
+      fields.push(field);
+      if (i < line.length && line[i] === delimiter) {
+        i++;
+      }
+    } else {
+      const end = line.indexOf(delimiter, i);
+      if (end === -1) {
+        fields.push(line.slice(i));
+        break;
+      } else {
+        fields.push(line.slice(i, end));
+        i = end + 1;
+      }
+    }
+  }
+  return fields;
+}
+function csvToJson(csv, delimiter = ",") {
+  if (!csv || csv.trim() === "") {
+    return { error: "Empty CSV input" };
+  }
+  const lines = csv.split(/\r?\n/).filter((line) => line.trim() !== "");
+  if (lines.length === 0) {
+    return { error: "No data in CSV" };
+  }
+  if (lines.length === 1) {
+    return JSON.stringify([]);
+  }
+  const headers = _parseRow(lines[0], delimiter);
+  const result = [];
+  for (let i = 1; i < lines.length; i++) {
+    const fields = _parseRow(lines[i], delimiter);
+    const obj = {};
+    for (let j = 0; j < headers.length; j++) {
+      obj[headers[j]] = fields[j] ?? "";
+    }
+    result.push(obj);
+  }
+  return JSON.stringify(result);
+}
+function _tokenize(path) {
+  const segments = [];
+  let i = 0;
+  if (path[i] !== "$") {
+    return { error: "Path must start with $" };
+  }
+  segments.push({ kind: "root" });
+  i++;
+  while (i < path.length) {
+    if (path[i] === "." && path[i + 1] === ".") {
+      i += 2;
+      const start = i;
+      while (i < path.length && path[i] !== "." && path[i] !== "[") {
+        i++;
+      }
+      const key = path.slice(start, i);
+      if (!key) return { error: "Expected key after .." };
+      segments.push({ kind: "recursive", key });
+      continue;
+    }
+    if (path[i] === ".") {
+      i++;
+      if (path[i] === "*") {
+        segments.push({ kind: "wildcardValues" });
+        i++;
+        continue;
+      }
+      const start = i;
+      while (i < path.length && path[i] !== "." && path[i] !== "[") {
+        i++;
+      }
+      const key = path.slice(start, i);
+      if (!key) return { error: "Expected key after ." };
+      segments.push({ kind: "key", key });
+      continue;
+    }
+    if (path[i] === "[") {
+      i++;
+      if (path[i] === "*") {
+        i++;
+        if (path[i] !== "]") return { error: "Expected ']' after [*" };
+        i++;
+        segments.push({ kind: "wildcard" });
+        continue;
+      }
+      if (path[i] === "'" || path[i] === '"') {
+        const quote = path[i];
+        i++;
+        const start2 = i;
+        while (i < path.length && path[i] !== quote) {
+          i++;
+        }
+        const key = path.slice(start2, i);
+        i++;
+        if (path[i] !== "]") return { error: "Expected ']'" };
+        i++;
+        segments.push({ kind: "key", key });
+        continue;
+      }
+      const start = i;
+      if (path[i] === "-") i++;
+      while (i < path.length && path[i] >= "0" && path[i] <= "9") {
+        i++;
+      }
+      const numStr = path.slice(start, i);
+      if (numStr === "" || numStr === "-") return { error: "Invalid index" };
+      const index = parseInt(numStr, 10);
+      if (path[i] !== "]") return { error: "Expected ']'" };
+      i++;
+      segments.push({ kind: "index", index });
+      continue;
+    }
+    return { error: `Unexpected character at position ${i}: '${path[i]}'` };
+  }
+  return segments;
+}
+function _applySegment(items, segment) {
+  const result = [];
+  for (const { value, path } of items) {
+    switch (segment.kind) {
+      case "root":
+        result.push({ value, path });
+        break;
+      case "key": {
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+          const obj = value;
+          if (Object.prototype.hasOwnProperty.call(obj, segment.key)) {
+            result.push({
+              value: obj[segment.key],
+              path: `${path}.${segment.key}`
+            });
+          }
+        }
+        break;
+      }
+      case "index": {
+        if (Array.isArray(value)) {
+          const idx = segment.index < 0 ? value.length + segment.index : segment.index;
+          if (idx >= 0 && idx < value.length) {
+            result.push({ value: value[idx], path: `${path}[${idx}]` });
+          }
+        }
+        break;
+      }
+      case "wildcard": {
+        if (Array.isArray(value)) {
+          for (let i = 0; i < value.length; i++) {
+            result.push({ value: value[i], path: `${path}[${i}]` });
+          }
+        }
+        break;
+      }
+      case "wildcardValues": {
+        if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+          const obj = value;
+          for (const [k, v] of Object.entries(obj)) {
+            result.push({ value: v, path: `${path}.${k}` });
+          }
+        }
+        break;
+      }
+      case "recursive": {
+        let recurse2 = function(val, p) {
+          if (val !== null && typeof val === "object") {
+            if (!Array.isArray(val)) {
+              const obj = val;
+              if (Object.prototype.hasOwnProperty.call(obj, recursiveKey)) {
+                collected.push({ value: obj[recursiveKey], path: `${p}.${recursiveKey}` });
+              }
+              for (const [k, v] of Object.entries(obj)) {
+                recurse2(v, `${p}.${k}`);
+              }
+            } else {
+              for (let i = 0; i < val.length; i++) {
+                recurse2(val[i], `${p}[${i}]`);
+              }
+            }
+          }
+        };
+        const recursiveKey = segment.key;
+        const collected = [];
+        recurse2(value, path);
+        result.push(...collected);
+        break;
+      }
+    }
+  }
+  return result;
+}
+function evaluateJsonPath(json, path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return { matches: [], count: 0, paths: [], error: "Invalid JSON input" };
+  }
+  const validation = validateJsonPath(path);
+  if (!validation.valid) {
+    return { matches: [], count: 0, paths: [], error: validation.error };
+  }
+  const segments = _tokenize(path);
+  if ("error" in segments) {
+    return { matches: [], count: 0, paths: [], error: segments.error };
+  }
+  let current = [{ value: parsed, path: "$" }];
+  for (const segment of segments) {
+    if (segment.kind === "root") continue;
+    current = _applySegment(current, segment);
+  }
+  return {
+    matches: current.map((c) => c.value),
+    count: current.length,
+    paths: current.map((c) => c.path)
+  };
+}
+function validateJsonPath(path) {
+  if (!path || typeof path !== "string") {
+    return { valid: false, error: "Path must be a non-empty string" };
+  }
+  if (!path.startsWith("$")) {
+    return { valid: false, error: "Path must start with '$'" };
+  }
+  const invalidChars = /[^a-zA-Z0-9$._\[\]*'"@\-]/;
+  if (invalidChars.test(path)) {
+    return { valid: false, error: "Path contains invalid characters" };
+  }
+  return { valid: true };
+}
+function _resolveRef(ref, root) {
+  const parts = ref.replace(/^#\//, "").split("/");
+  let node = root;
+  for (const part of parts) {
+    if (!_isObject(node)) return null;
+    node = node[part];
+  }
+  return _isObject(node) ? node : null;
+}
+function _validateSchema(data, schema, path, root, errors) {
+  if (schema["$ref"] !== void 0) {
+    const ref = schema["$ref"];
+    const resolved = _resolveRef(ref, root);
+    if (!resolved) {
+      errors.push({ path, message: `Cannot resolve $ref: ${ref}` });
+      return;
+    }
+    _validateSchema(data, resolved, path, root, errors);
+    return;
+  }
+  if ("const" in schema) {
+    if (JSON.stringify(data) !== JSON.stringify(schema["const"])) {
+      errors.push({ path, message: `Value must be ${JSON.stringify(schema["const"])}` });
+    }
+  }
+  if ("enum" in schema) {
+    const enums = schema["enum"];
+    if (!enums.some((e) => JSON.stringify(e) === JSON.stringify(data))) {
+      errors.push({ path, message: `Value must be one of: ${enums.map((e) => JSON.stringify(e)).join(", ")}` });
+    }
+  }
+  if ("type" in schema) {
+    const types = Array.isArray(schema["type"]) ? schema["type"] : [schema["type"]];
+    const valid = types.some((t) => _matchesType(data, t));
+    if (!valid) {
+      errors.push({ path, message: `Expected type ${types.join(" or ")}, got ${_getType(data)}` });
+      return;
+    }
+  }
+  if ("allOf" in schema) {
+    const allOf = schema["allOf"];
+    for (const sub of allOf) {
+      _validateSchema(data, sub, path, root, errors);
+    }
+  }
+  if ("anyOf" in schema) {
+    const anyOf = schema["anyOf"];
+    const anyValid = anyOf.some((sub) => {
+      const subErrors = [];
+      _validateSchema(data, sub, path, root, subErrors);
+      return subErrors.length === 0;
+    });
+    if (!anyValid) {
+      errors.push({ path, message: "Value must match at least one of the anyOf schemas" });
+    }
+  }
+  if ("oneOf" in schema) {
+    const oneOf = schema["oneOf"];
+    const matchCount = oneOf.filter((sub) => {
+      const subErrors = [];
+      _validateSchema(data, sub, path, root, subErrors);
+      return subErrors.length === 0;
+    }).length;
+    if (matchCount !== 1) {
+      errors.push({ path, message: `Value must match exactly one of the oneOf schemas, matched ${matchCount}` });
+    }
+  }
+  if ("not" in schema) {
+    const notErrors = [];
+    _validateSchema(data, schema["not"], path, root, notErrors);
+    if (notErrors.length === 0) {
+      errors.push({ path, message: "Value must not match the not schema" });
+    }
+  }
+  if (typeof data === "string") {
+    _validateString(data, schema, path, errors);
+  }
+  if (typeof data === "number") {
+    _validateNumber(data, schema, path, errors);
+  }
+  if (Array.isArray(data)) {
+    _validateArray(data, schema, path, root, errors);
+  }
+  if (_isObject(data)) {
+    _validateObject(data, schema, path, root, errors);
+  }
+}
+function _matchesType(data, type) {
+  switch (type) {
+    case "string":
+      return typeof data === "string";
+    case "number":
+      return typeof data === "number";
+    case "integer":
+      return typeof data === "number" && Number.isInteger(data);
+    case "boolean":
+      return typeof data === "boolean";
+    case "null":
+      return data === null;
+    case "array":
+      return Array.isArray(data);
+    case "object":
+      return _isObject(data);
+    default:
+      return true;
+  }
+}
+function _getType(data) {
+  if (data === null) return "null";
+  if (Array.isArray(data)) return "array";
+  return typeof data;
+}
+function _validateString(data, schema, path, errors) {
+  if ("minLength" in schema && data.length < schema["minLength"]) {
+    errors.push({ path, message: `String must be at least ${schema["minLength"]} characters` });
+  }
+  if ("maxLength" in schema && data.length > schema["maxLength"]) {
+    errors.push({ path, message: `String must be at most ${schema["maxLength"]} characters` });
+  }
+  if ("pattern" in schema) {
+    const re = new RegExp(schema["pattern"]);
+    if (!re.test(data)) {
+      errors.push({ path, message: `String must match pattern ${schema["pattern"]}` });
+    }
+  }
+}
+function _validateNumber(data, schema, path, errors) {
+  if ("minimum" in schema && data < schema["minimum"]) {
+    errors.push({ path, message: `Value must be >= ${schema["minimum"]}` });
+  }
+  if ("maximum" in schema && data > schema["maximum"]) {
+    errors.push({ path, message: `Value must be <= ${schema["maximum"]}` });
+  }
+  if ("exclusiveMinimum" in schema) {
+    const excMin = schema["exclusiveMinimum"];
+    if (typeof excMin === "number" && data <= excMin) {
+      errors.push({ path, message: `Value must be > ${excMin}` });
+    } else if (excMin === true && "minimum" in schema && data <= schema["minimum"]) {
+      errors.push({ path, message: `Value must be > ${schema["minimum"]}` });
+    }
+  }
+  if ("exclusiveMaximum" in schema) {
+    const excMax = schema["exclusiveMaximum"];
+    if (typeof excMax === "number" && data >= excMax) {
+      errors.push({ path, message: `Value must be < ${excMax}` });
+    } else if (excMax === true && "maximum" in schema && data >= schema["maximum"]) {
+      errors.push({ path, message: `Value must be < ${schema["maximum"]}` });
+    }
+  }
+  if ("multipleOf" in schema) {
+    const mo = schema["multipleOf"];
+    if (data % mo !== 0) {
+      errors.push({ path, message: `Value must be a multiple of ${mo}` });
+    }
+  }
+}
+function _validateArray(data, schema, path, root, errors) {
+  if ("minItems" in schema && data.length < schema["minItems"]) {
+    errors.push({ path, message: `Array must have at least ${schema["minItems"]} items` });
+  }
+  if ("maxItems" in schema && data.length > schema["maxItems"]) {
+    errors.push({ path, message: `Array must have at most ${schema["maxItems"]} items` });
+  }
+  if ("uniqueItems" in schema && schema["uniqueItems"] === true) {
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < data.length; i++) {
+      const key = JSON.stringify(data[i]);
+      if (seen.has(key)) {
+        errors.push({ path: `${path}/${i}`, message: "Array items must be unique" });
+      }
+      seen.add(key);
+    }
+  }
+  if ("items" in schema) {
+    const items = schema["items"];
+    if (_isObject(items)) {
+      for (let i = 0; i < data.length; i++) {
+        _validateSchema(data[i], items, `${path}/${i}`, root, errors);
+      }
+    } else if (Array.isArray(items)) {
+      for (let i = 0; i < items.length; i++) {
+        if (i < data.length) {
+          _validateSchema(data[i], items[i], `${path}/${i}`, root, errors);
+        }
+      }
+    }
+  }
+}
+function _validateObject(data, schema, path, root, errors) {
+  const keys = Object.keys(data);
+  if ("minProperties" in schema && keys.length < schema["minProperties"]) {
+    errors.push({ path, message: `Object must have at least ${schema["minProperties"]} properties` });
+  }
+  if ("maxProperties" in schema && keys.length > schema["maxProperties"]) {
+    errors.push({ path, message: `Object must have at most ${schema["maxProperties"]} properties` });
+  }
+  if ("required" in schema) {
+    const required = schema["required"];
+    for (const key of required) {
+      if (!(key in data)) {
+        errors.push({ path: `${path}/${key}`, message: `Required property '${key}' is missing` });
+      }
+    }
+  }
+  const properties = _isObject(schema["properties"]) ? schema["properties"] : {};
+  for (const key of keys) {
+    if (key in properties) {
+      _validateSchema(data[key], properties[key], `${path}/${key}`, root, errors);
+    } else if ("additionalProperties" in schema) {
+      const ap = schema["additionalProperties"];
+      if (ap === false) {
+        errors.push({ path: `${path}/${key}`, message: `Additional property '${key}' is not allowed` });
+      } else if (_isObject(ap)) {
+        _validateSchema(data[key], ap, `${path}/${key}`, root, errors);
+      }
+    }
+  }
+}
+function validateJson(data, schema) {
+  const errors = [];
+  _validateSchema(data, schema, "#", schema, errors);
+  return { valid: errors.length === 0, errors };
+}
+function validateJsonString(dataStr, schemaStr) {
+  let data;
+  let schema;
+  try {
+    data = JSON.parse(dataStr);
+  } catch (e) {
+    return { parseError: `Invalid data JSON: ${e.message}` };
+  }
+  try {
+    schema = JSON.parse(schemaStr);
+  } catch (e) {
+    return { parseError: `Invalid schema JSON: ${e.message}` };
+  }
+  return validateJson(data, schema);
+}
+function generateExample(schema) {
+  return _generateExampleFromSchema(schema, schema);
+}
+function _generateExampleFromSchema(schema, root) {
+  if (schema["$ref"] !== void 0) {
+    const resolved = _resolveRef(schema["$ref"], root);
+    if (resolved) return _generateExampleFromSchema(resolved, root);
+    return null;
+  }
+  if ("const" in schema) return schema["const"];
+  if ("enum" in schema) return schema["enum"][0];
+  if ("examples" in schema) return schema["examples"][0];
+  if ("default" in schema) return schema["default"];
+  if ("allOf" in schema) {
+    const result = {};
+    for (const sub of schema["allOf"]) {
+      const ex = _generateExampleFromSchema(sub, root);
+      if (_isObject(ex)) Object.assign(result, ex);
+    }
+    return result;
+  }
+  if ("anyOf" in schema) return _generateExampleFromSchema(schema["anyOf"][0], root);
+  if ("oneOf" in schema) return _generateExampleFromSchema(schema["oneOf"][0], root);
+  const type = Array.isArray(schema["type"]) ? schema["type"][0] : schema["type"];
+  switch (type) {
+    case "string": {
+      if (schema["pattern"]) return "example";
+      const minLen = schema["minLength"] || 0;
+      return "example".padEnd(Math.max(minLen, 7), "x").slice(0, schema["maxLength"] || 100);
+    }
+    case "number":
+    case "integer": {
+      const min = schema["minimum"] ?? schema["exclusiveMinimum"] ?? 0;
+      return type === "integer" ? Math.ceil(min) : min;
+    }
+    case "boolean":
+      return true;
+    case "null":
+      return null;
+    case "array": {
+      const items = schema["items"];
+      const minItems = schema["minItems"] || 1;
+      const count = Math.max(minItems, 1);
+      if (_isObject(items)) {
+        return Array.from({ length: count }, () => _generateExampleFromSchema(items, root));
+      }
+      return [];
+    }
+    case "object": {
+      const result = {};
+      const props = _isObject(schema["properties"]) ? schema["properties"] : {};
+      const required = schema["required"] || Object.keys(props).slice(0, 3);
+      for (const key of required) {
+        if (key in props) {
+          result[key] = _generateExampleFromSchema(props[key], root);
+        } else {
+          result[key] = "value";
+        }
+      }
+      return result;
+    }
+    default: {
+      if (_isObject(schema["properties"])) {
+        return _generateExampleFromSchema({ ...schema, type: "object" }, root);
+      }
+      return null;
+    }
+  }
+}
+function yamlToJson(input, pretty = true) {
+  try {
+    const trimmed = input.trim();
+    if (trimmed === "") return JSON.stringify(null, null, pretty ? 2 : void 0);
+    const parsed = yaml__namespace.load(trimmed);
+    const value = parsed === void 0 ? null : parsed;
+    return JSON.stringify(value, null, pretty ? 2 : void 0);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function jsonToYaml(input) {
+  try {
+    const parsed = JSON.parse(input);
+    return yaml__namespace.dump(parsed);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function detectFormat(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return "json";
+  }
+  if (trimmed.includes(": ") && !trimmed.startsWith("{")) {
+    return "yaml";
+  }
+  return "unknown";
+}
+function inferType(value, name, interfaces) {
+  if (value === null) return "null";
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "unknown[]";
+    const elementTypes = value.map((item) => inferType(item, `${name}Item`, interfaces));
+    const uniqueTypes = [...new Set(elementTypes)];
+    if (uniqueTypes.length === 1) {
+      return `${uniqueTypes[0]}[]`;
+    }
+    const allObjects = value.every((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+    if (allObjects) {
+      const merged = {};
+      for (const item of value) {
+        for (const [k, v] of Object.entries(item)) {
+          if (!(k in merged)) merged[k] = v;
+        }
+      }
+      const itemName = `${name}Item`;
+      _buildInterface(merged, itemName, interfaces);
+      return `${itemName}[]`;
+    }
+    return "unknown[]";
+  }
+  if (typeof value === "object" && value !== null) {
+    _buildInterface(value, name, interfaces);
+    return name;
+  }
+  return "unknown";
+}
+function _buildInterface(obj, name, interfaces, useType, optionalFields = false) {
+  const lines = [];
+  {
+    lines.push(`interface ${name} {`);
+  }
+  for (const [key, val] of Object.entries(obj)) {
+    const fieldName = optionalFields ? `${key}?` : key;
+    const subName = _capitalize(key);
+    const subInterfaces = [];
+    const typeName = inferType(val, subName, subInterfaces);
+    for (const sub of subInterfaces) {
+      if (!interfaces.includes(sub)) {
+        interfaces.push(sub);
+      }
+    }
+    lines.push(`  ${fieldName}: ${typeName};`);
+  }
+  lines.push("}");
+  const result = lines.join("\n");
+  if (!interfaces.includes(result)) {
+    interfaces.push(result);
+  }
+}
+function _capitalize(str) {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function jsonToTypescript(json, options) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return { error: "Invalid JSON input" };
+  }
+  const rootName = options?.rootName ?? "Root";
+  const useInterface = options?.useInterface ?? true;
+  const optionalFields = options?.optionalFields ?? false;
+  const interfaces = [];
+  if (parsed === null) {
+    return `type ${rootName} = null;`;
+  }
+  if (typeof parsed !== "object" && !Array.isArray(parsed)) {
+    const t = inferType(parsed, rootName, interfaces);
+    return `type ${rootName} = ${t};`;
+  }
+  if (Array.isArray(parsed)) {
+    const subInterfaces = [];
+    const elementType = inferType(parsed, rootName, subInterfaces);
+    const parts = [...subInterfaces];
+    const declaration = `type ${rootName} = ${elementType};`;
+    parts.push(declaration);
+    return parts.join("\n\n");
+  }
+  const obj = parsed;
+  const lines = [];
+  const fieldLines = [];
+  for (const [key, val] of Object.entries(obj)) {
+    const fieldName = optionalFields ? `${key}?` : key;
+    const subName = _capitalize(key);
+    const subInterfaces = [];
+    const typeName = inferType(val, subName, subInterfaces);
+    for (const sub of subInterfaces) {
+      interfaces.push(sub);
+    }
+    fieldLines.push(`  ${fieldName}: ${typeName};`);
+  }
+  if (useInterface) {
+    lines.push(`interface ${rootName} {`);
+  } else {
+    lines.push(`type ${rootName} = {`);
+  }
+  lines.push(...fieldLines);
+  lines.push("}");
+  const rootDecl = lines.join("\n");
+  const allParts = [...interfaces, rootDecl];
+  return allParts.join("\n\n");
+}
+function toPascalCase(key) {
+  return key.replace(/[-_\s]+(.)/g, (_, char) => char.toUpperCase()).replace(/([a-z])([A-Z])/g, "$1 $2").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("").replace(/^(.)/, (c) => c.toUpperCase());
+}
+function inferGoType(value, fieldName) {
+  if (value === null) return "interface{}";
+  if (typeof value === "string") return "string";
+  if (typeof value === "boolean") return "bool";
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? "int64" : "float64";
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]interface{}";
+    const allObjects = value.every((v) => v !== null && typeof v === "object" && !Array.isArray(v));
+    if (allObjects) {
+      if (fieldName) {
+        const singular = _toSingular(toPascalCase(fieldName));
+        return `[]${singular}`;
+      }
+      return "[]interface{}";
+    }
+    const elementTypes = new Set(value.map((v) => inferGoType(v)));
+    if (elementTypes.size > 1) return "[]interface{}";
+    const elemType = elementTypes.values().next().value;
+    if (elemType === "string") return "[]string";
+    if (elemType === "int64") return "[]int64";
+    if (elemType === "float64") return "[]float64";
+    if (elemType === "bool") return "[]bool";
+    return "[]interface{}";
+  }
+  if (typeof value === "object") {
+    if (fieldName) return toPascalCase(fieldName);
+    return "interface{}";
+  }
+  return "interface{}";
+}
+function _toSingular(name) {
+  if (name.endsWith("ies")) return name.slice(0, -3) + "y";
+  if (name.endsWith("ses") || name.endsWith("xes") || name.endsWith("zes")) return name.slice(0, -2);
+  if (name.endsWith("s") && !name.endsWith("ss")) return name.slice(0, -1);
+  return name;
+}
+function _collectStructs(obj, structName, structs) {
+  const fields = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const fieldName = toPascalCase(key);
+    let goType = inferGoType(value, key);
+    const omitempty = value === null || value === void 0;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const nestedName = toPascalCase(key);
+      _collectStructs(value, nestedName, structs);
+      goType = nestedName;
+    }
+    if (Array.isArray(value) && value.length > 0) {
+      const firstNonNull = value.find((v) => v !== null && typeof v === "object" && !Array.isArray(v));
+      if (firstNonNull) {
+        const elemName = _toSingular(toPascalCase(key));
+        _collectStructs(firstNonNull, elemName, structs);
+        goType = `[]${elemName}`;
+      }
+    }
+    fields.push({ name: fieldName, jsonKey: key, goType, omitempty });
+  }
+  structs.set(structName, { name: structName, fields });
+}
+function parseStructs(json, rootName = "Root") {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return { error: "Invalid JSON" };
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    if (Array.isArray(parsed)) {
+      const firstObj = parsed.find(
+        (v) => v !== null && typeof v === "object" && !Array.isArray(v)
+      );
+      if (firstObj) {
+        const structs2 = /* @__PURE__ */ new Map();
+        _collectStructs(firstObj, rootName, structs2);
+        return Array.from(structs2.values());
+      }
+      return [{ name: rootName, fields: [] }];
+    }
+    return { error: "JSON root must be an object or array of objects" };
+  }
+  const structs = /* @__PURE__ */ new Map();
+  _collectStructs(parsed, rootName, structs);
+  return Array.from(structs.values());
+}
+function _formatStructs(structs) {
+  return structs.map((s) => {
+    const maxNameLen = s.fields.reduce((m, f) => Math.max(m, f.name.length), 0);
+    const maxTypeLen = s.fields.reduce((m, f) => Math.max(m, f.goType.length), 0);
+    const fieldLines = s.fields.map((f) => {
+      const paddedName = f.name.padEnd(maxNameLen + 1);
+      const paddedType = f.goType.padEnd(maxTypeLen + 1);
+      const tag = f.omitempty ? `\`json:"${f.jsonKey},omitempty"\`` : `\`json:"${f.jsonKey}"\``;
+      return `	${paddedName}${paddedType}${tag}`;
+    });
+    return `type ${s.name} struct {
+${fieldLines.join("\n")}
+}`;
+  }).join("\n\n");
+}
+function jsonToGo(json, rootTypeName = "Root") {
+  const structsResult = parseStructs(json, rootTypeName);
+  if ("error" in structsResult) return structsResult;
+  if (structsResult.length === 0) {
+    return `type ${rootTypeName} struct {}`;
+  }
+  return _formatStructs(structsResult);
+}
+function toSnakeCase(key) {
+  return key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/-/g, "_").toLowerCase();
+}
+function inferPythonType(value, fieldName) {
+  if (value === null) return "None";
+  if (typeof value === "boolean") return "bool";
+  if (typeof value === "string") return "str";
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? "int" : "float";
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "List[Any]";
+    const allStrings = value.every((v) => typeof v === "string");
+    if (allStrings) return "List[str]";
+    const allInts = value.every((v) => typeof v === "number" && Number.isInteger(v));
+    if (allInts) return "List[int]";
+    const allFloats = value.every((v) => typeof v === "number");
+    if (allFloats) return "List[float]";
+    const allBools = value.every((v) => typeof v === "boolean");
+    if (allBools) return "List[bool]";
+    const allObjects = value.every(
+      (v) => v !== null && typeof v === "object" && !Array.isArray(v)
+    );
+    if (allObjects) {
+      const className = fieldName ? fieldName.charAt(0).toUpperCase() + fieldName.slice(1) : "Item";
+      return `List[${className}]`;
+    }
+    return "List[Any]";
+  }
+  if (typeof value === "object") {
+    const className = fieldName ? fieldName.charAt(0).toUpperCase() + fieldName.slice(1) : "Object";
+    return className;
+  }
+  return "Any";
+}
+function _collectPythonClasses(obj, className, mode, classes) {
+  const fields = [];
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = toSnakeCase(key);
+    let optional = false;
+    if (value === null) {
+      optional = true;
+    }
+    const pyType = inferPythonType(value, snakeKey);
+    fields.push({ name: snakeKey, jsonKey: key, pyType, optional });
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      const nestedClassName = snakeKey.charAt(0).toUpperCase() + snakeKey.slice(1);
+      _collectPythonClasses(value, nestedClassName, mode, classes);
+    }
+    if (Array.isArray(value) && value.length > 0) {
+      const allObjects = value.every(
+        (v) => v !== null && typeof v === "object" && !Array.isArray(v)
+      );
+      if (allObjects) {
+        const nestedClassName = snakeKey.charAt(0).toUpperCase() + snakeKey.slice(1);
+        const merged = {};
+        for (const item of value) {
+          for (const [k, v] of Object.entries(item)) {
+            if (!(k in merged)) {
+              merged[k] = v;
+            }
+          }
+        }
+        _collectPythonClasses(merged, nestedClassName, mode, classes);
+      }
+    }
+  }
+  classes.push({ name: className, fields, mode });
+}
+function _renderPythonClass(cls) {
+  const { name, fields, mode } = cls;
+  const lines = [];
+  if (mode === "typeddict") {
+    lines.push(`class ${name}(TypedDict):`);
+    if (fields.length === 0) {
+      lines.push("    pass");
+    } else {
+      for (const field of fields) {
+        const t = field.optional ? `Optional[${field.pyType}]` : field.pyType;
+        lines.push(`    ${field.name}: ${t}`);
+      }
+    }
+  } else if (mode === "dataclass") {
+    lines.push("@dataclass");
+    lines.push(`class ${name}:`);
+    if (fields.length === 0) {
+      lines.push("    pass");
+    } else {
+      for (const field of fields) {
+        const t = field.optional ? `Optional[${field.pyType}]` : field.pyType;
+        const defaultVal = field.optional ? " = None" : "";
+        lines.push(`    ${field.name}: ${t}${defaultVal}`);
+      }
+    }
+  } else {
+    lines.push(`class ${name}(BaseModel):`);
+    if (fields.length === 0) {
+      lines.push("    pass");
+    } else {
+      for (const field of fields) {
+        const t = field.optional ? `Optional[${field.pyType}]` : field.pyType;
+        const defaultVal = field.optional ? " = None" : "";
+        lines.push(`    ${field.name}: ${t}${defaultVal}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function jsonToPython(json, rootName, mode) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (e) {
+    return { error: `Invalid JSON: ${e.message}` };
+  }
+  const resolvedMode = mode ?? "typeddict";
+  const resolvedRoot = rootName ?? "Root";
+  let topObj;
+  if (Array.isArray(parsed)) {
+    topObj = { items: parsed };
+  } else if (parsed !== null && typeof parsed === "object") {
+    topObj = parsed;
+  } else {
+    return { error: "Top-level JSON must be an object or array" };
+  }
+  const classes = [];
+  _collectPythonClasses(topObj, resolvedRoot, resolvedMode, classes);
+  const headerLines = [];
+  if (resolvedMode === "typeddict") {
+    headerLines.push("from typing import TypedDict, List, Optional, Any");
+  } else if (resolvedMode === "dataclass") {
+    headerLines.push("from dataclasses import dataclass");
+    headerLines.push("from typing import List, Optional, Any");
+  } else {
+    headerLines.push("from pydantic import BaseModel");
+    headerLines.push("from typing import List, Optional, Any");
+  }
+  const classBlocks = classes.map(_renderPythonClass);
+  const output = [...headerLines, "", ...classBlocks].join("\n\n");
+  return output;
+}
+function _valueToZodType(value, coerce = false) {
+  if (value === null) return "z.null()";
+  if (typeof value === "string") return "z.string()";
+  if (typeof value === "number") return coerce ? "z.coerce.number()" : "z.number()";
+  if (typeof value === "boolean") return coerce ? "z.coerce.boolean()" : "z.boolean()";
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "z.array(z.unknown())";
+    const elementType = _valueToZodType(value[0], coerce);
+    return `z.array(${elementType})`;
+  }
+  if (typeof value === "object") {
+    return _objectToZodSchema(value, coerce);
+  }
+  return "z.unknown()";
+}
+function _objectToZodSchema(obj, coerce = false) {
+  const entries = Object.entries(obj).map(([key, val]) => `  ${key}: ${_valueToZodType(val, coerce)}`).join(",\n");
+  return `z.object({
+${entries}
+})`;
+}
+function jsonToZod(json, options) {
+  const rootName = options?.rootName ?? "Root";
+  const coerce = options?.coerce ?? false;
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+  const schema = _valueToZodType(parsed, coerce);
+  return `import { z } from 'zod'
+
+export const ${rootName}Schema = ${schema}`;
+}
+
+exports.csvToJson = csvToJson;
+exports.detectFormat = detectFormat;
+exports.diffJson = diffJson;
+exports.evaluateJsonPath = evaluateJsonPath;
+exports.formatDiffLine = formatDiffLine;
+exports.formatJson = formatJson;
+exports.generateExample = generateExample;
+exports.getJsonStats = getJsonStats;
+exports.inferGoType = inferGoType;
+exports.inferPythonType = inferPythonType;
+exports.inferType = inferType;
+exports.jsonToCsv = jsonToCsv;
+exports.jsonToGo = jsonToGo;
+exports.jsonToPython = jsonToPython;
+exports.jsonToTypescript = jsonToTypescript;
+exports.jsonToYaml = jsonToYaml;
+exports.jsonToZod = jsonToZod;
+exports.minifyJson = minifyJson;
+exports.parseJson = parseJson;
+exports.parseStructs = parseStructs;
+exports.toPascalCase = toPascalCase;
+exports.toSnakeCase = toSnakeCase;
+exports.validateJson = validateJson;
+exports.validateJsonPath = validateJsonPath;
+exports.validateJsonString = validateJsonString;
+exports.yamlToJson = yamlToJson;