opkg 0.9.0 → 0.9.2

package/packages/cli/dist/chunk-IXOEIRDT.js

@@ -0,0 +1,1028 @@
+#!/usr/bin/env node
+import {
+  logger
+} from "./chunk-5EFWGD33.js";
+
+// ../core/src/core/flows/map-pipeline/utils.ts
+import { minimatch } from "minimatch";
+function getNestedValue(obj, path) {
+  if (!path)
+    return obj;
+  let keys = path.split("."), current = obj;
+  for (let key of keys)
+    if (current && typeof current == "object" && key in current)
+      current = current[key];
+    else
+      return;
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  if (!path)
+    return;
+  let keys = path.split("."), current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    let key = keys[i];
+    (!(key in current) || typeof current[key] != "object" || current[key] === null) && (current[key] = {}), current = current[key];
+  }
+  let finalKey = keys[keys.length - 1];
+  current[finalKey] = value;
+}
+function deleteNestedValue(obj, path) {
+  if (!path)
+    return;
+  let keys = path.split("."), current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    let key = keys[i];
+    if (!(key in current) || typeof current[key] != "object")
+      return;
+    current = current[key];
+  }
+  let finalKey = keys[keys.length - 1];
+  delete current[finalKey];
+}
+function matchPattern(value, pattern) {
+  if (pattern === "*")
+    return !0;
+  if (typeof pattern == "string")
+    return typeof value != "string" ? !1 : minimatch(value, pattern);
+  if (typeof pattern == "object" && pattern !== null) {
+    if (typeof value != "object" || value === null)
+      return !1;
+    for (let [key, patternValue] of Object.entries(pattern))
+      if (key === "*") {
+        if (!Object.values(value).every((v) => patternValue === "*" ? !0 : v === patternValue)) return !1;
+      } else if (!(key in value) || patternValue !== "*" && value[key] !== patternValue)
+        return !1;
+    return !0;
+  }
+  return value === pattern;
+}
+function getFlatKeys(obj, prefix = "") {
+  let keys = [];
+  if (typeof obj != "object" || obj === null)
+    return [];
+  for (let [key, value] of Object.entries(obj)) {
+    let fullKey = prefix ? `${prefix}.${key}` : key;
+    keys.push(fullKey), typeof value == "object" && value !== null && !Array.isArray(value) && keys.push(...getFlatKeys(value, fullKey));
+  }
+  return keys;
+}
+function parseWildcard(pattern) {
+  let wildcardIndex = pattern.indexOf("*");
+  if (wildcardIndex === -1)
+    return { prefix: pattern, suffix: "" };
+  let prefix = pattern.substring(0, wildcardIndex), suffix = pattern.substring(wildcardIndex + 1);
+  return { prefix, suffix };
+}
+function getMatchingKeys(obj, prefix, suffix) {
+  return getFlatKeys(obj).filter((key) => prefix && !key.startsWith(prefix) || suffix && !key.endsWith(suffix) ? !1 : extractWildcardPart(key, prefix, suffix).length > 0);
+}
+function extractWildcardPart(key, prefix, suffix) {
+  let result = key;
+  return prefix && (result = result.substring(prefix.length)), suffix && (result = result.substring(0, result.length - suffix.length)), result;
+}
+function resolveWildcardPaths(document, pattern) {
+  let segments = pattern.split("."), results = [];
+  function traverse(obj, depth, currentPath) {
+    if (depth >= segments.length) {
+      results.push(currentPath.join("."));
+      return;
+    }
+    let segment = segments[depth];
+    if (segment === "*") {
+      if (typeof obj == "object" && obj !== null && !Array.isArray(obj))
+        for (let key of Object.keys(obj))
+          traverse(obj[key], depth + 1, [...currentPath, key]);
+    } else
+      typeof obj == "object" && obj !== null && segment in obj && traverse(obj[segment], depth + 1, [...currentPath, segment]);
+  }
+  return traverse(document, 0, []), results;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj != "object")
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map((item) => deepClone(item));
+  let cloned = {};
+  for (let [key, value] of Object.entries(obj))
+    cloned[key] = deepClone(value);
+  return cloned;
+}
+
+// ../core/src/core/flows/map-pipeline/context.ts
+function resolveValue(value, context) {
+  if (typeof value == "string") {
+    if (value.startsWith("\\$$"))
+      return value.substring(1);
+    if (value.startsWith("$$")) {
+      let varName = value.substring(2);
+      return varName in context ? context[varName] : value;
+    }
+    return value;
+  }
+  if (typeof value == "object" && value !== null) {
+    if (Array.isArray(value))
+      return value.map((item) => resolveValue(item, context));
+    let result = {};
+    for (let [key, val] of Object.entries(value))
+      result[key] = resolveValue(val, context);
+    return result;
+  }
+  return value;
+}
+
+// ../core/src/core/flows/map-pipeline/operations/set.ts
+function executeSet(document, operation, context) {
+  let result = { ...document }, fields = operation.$set;
+  for (let [fieldPath, value] of Object.entries(fields)) {
+    let resolvedValue = resolveValue(value, context);
+    setNestedValue(result, fieldPath, resolvedValue);
+  }
+  return result;
+}
+function validateSet(operation) {
+  let errors = [];
+  if (!operation.$set || typeof operation.$set != "object")
+    return errors.push("$set must be an object"), { valid: !1, errors };
+  Object.keys(operation.$set).length === 0 && errors.push("$set must have at least one field");
+  for (let [key, value] of Object.entries(operation.$set))
+    (!key || key.trim() === "") && errors.push("$set field path cannot be empty");
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// ../core/src/core/flows/map-pipeline/operations/rename.ts
+function executeRename(document, operation) {
+  let result = { ...document }, mappings = operation.$rename;
+  for (let [oldPath, newPath] of Object.entries(mappings))
+    oldPath.includes("*") ? renameWithWildcard(result, oldPath, newPath) : renameSimple(result, oldPath, newPath);
+  return result;
+}
+function renameSimple(obj, oldPath, newPath) {
+  let value = getNestedValue(obj, oldPath);
+  value !== void 0 && (setNestedValue(obj, newPath, value), deleteNestedValue(obj, oldPath));
+}
+function renameWithWildcard(obj, oldPattern, newPattern) {
+  let { prefix: oldPrefix, suffix: oldSuffix } = parseWildcard(oldPattern), { prefix: newPrefix, suffix: newSuffix } = parseWildcard(newPattern), matchingKeys = getMatchingKeys(obj, oldPrefix, oldSuffix);
+  for (let oldKey of matchingKeys) {
+    let wildcardPart = extractWildcardPart(oldKey, oldPrefix, oldSuffix), newKey = newPrefix + wildcardPart + newSuffix, value = getNestedValue(obj, oldKey);
+    value !== void 0 && (setNestedValue(obj, newKey, value), deleteNestedValue(obj, oldKey));
+  }
+}
+function validateRename(operation) {
+  let errors = [];
+  if (!operation.$rename || typeof operation.$rename != "object")
+    return errors.push("$rename must be an object"), { valid: !1, errors };
+  Object.keys(operation.$rename).length === 0 && errors.push("$rename must have at least one field mapping");
+  for (let [oldPath, newPath] of Object.entries(operation.$rename)) {
+    (!oldPath || oldPath.trim() === "") && errors.push("$rename source path cannot be empty"), (!newPath || newPath.trim() === "") && errors.push("$rename target path cannot be empty");
+    let oldWildcards = (oldPath.match(/\*/g) || []).length, newWildcards = (newPath.match(/\*/g) || []).length;
+    oldWildcards !== newWildcards && errors.push(
+      `$rename wildcard mismatch: "${oldPath}" has ${oldWildcards} wildcard(s), but "${newPath}" has ${newWildcards} wildcard(s). Both must have the same count.`
+    ), oldWildcards > 1 && errors.push(`$rename does not support multiple wildcards in one pattern: "${oldPath}"`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// ../core/src/core/flows/map-pipeline/operations/unset.ts
+function executeUnset(document, operation) {
+  let result = { ...document }, fields = Array.isArray(operation.$unset) ? operation.$unset : [operation.$unset];
+  for (let fieldPath of fields)
+    if (fieldPath.includes("*")) {
+      let matchedPaths = resolveWildcardPaths(result, fieldPath);
+      for (let path of matchedPaths)
+        deleteNestedValue(result, path);
+    } else
+      deleteNestedValue(result, fieldPath);
+  return result;
+}
+function validateUnset(operation) {
+  let errors = [];
+  if (!operation.$unset)
+    return errors.push("$unset must be a string or array of strings"), { valid: !1, errors };
+  let fields = Array.isArray(operation.$unset) ? operation.$unset : [operation.$unset];
+  fields.length === 0 && errors.push("$unset must have at least one field");
+  for (let field of fields)
+    typeof field != "string" ? errors.push("$unset field must be a string") : (!field || field.trim() === "") && errors.push("$unset field path cannot be empty");
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// ../core/src/core/flows/map-pipeline/operations/switch.ts
+function executeSwitch(document, operation) {
+  let result = { ...document }, { field, cases, default: defaultValue } = operation.$switch, currentValue = getNestedValue(result, field);
+  if (currentValue === void 0)
+    return result;
+  for (let { pattern, value } of cases)
+    if (matchPattern(currentValue, pattern))
+      return setNestedValue(result, field, value), result;
+  return defaultValue !== void 0 && setNestedValue(result, field, defaultValue), result;
+}
+function validateSwitch(operation) {
+  let errors = [];
+  if (!operation.$switch || typeof operation.$switch != "object")
+    return errors.push("$switch must be an object"), { valid: !1, errors };
+  let config = operation.$switch;
+  if ((!config.field || typeof config.field != "string") && errors.push("$switch.field must be a non-empty string"), !config.cases || !Array.isArray(config.cases))
+    return errors.push("$switch.cases must be an array"), { valid: errors.length === 0, errors };
+  config.cases.length === 0 && errors.push("$switch.cases must have at least one case");
+  for (let i = 0; i < config.cases.length; i++) {
+    let switchCase = config.cases[i];
+    if (!switchCase || typeof switchCase != "object") {
+      errors.push(`$switch.cases[${i}] must be an object`);
+      continue;
+    }
+    "pattern" in switchCase || errors.push(`$switch.cases[${i}] must have a "pattern" field`), "value" in switchCase || errors.push(`$switch.cases[${i}] must have a "value" field`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// ../core/src/core/flows/map-pipeline/operations/transform.ts
+function executePipeline(document, operation, context) {
+  let result = { ...document }, { field, operations } = operation.$pipeline;
+  if (field.includes("*")) {
+    let matchedPaths = resolveWildcardPaths(result, field);
+    if (matchedPaths.length === 0)
+      return result;
+    for (let path of matchedPaths) {
+      let value = getNestedValue(result, path);
+      for (let step of operations)
+        value = applyPipelineStep(value, step, context);
+      value === "" || Array.isArray(value) && value.length === 0 ? deleteNestedValue(result, path) : setNestedValue(result, path, value);
+    }
+  } else {
+    let value = getNestedValue(result, field);
+    if (value === void 0)
+      return result;
+    for (let step of operations)
+      value = applyPipelineStep(value, step, context);
+    value === "" || Array.isArray(value) && value.length === 0 ? deleteNestedValue(result, field) : setNestedValue(result, field, value);
+  }
+  return result;
+}
+function applyPipelineStep(value, step, context) {
+  return "$filter" in step ? applyFilter(value, step.$filter) : "$objectToArray" in step ? applyObjectToArray(value, step.$objectToArray) : "$arrayToObject" in step ? applyArrayToObject(value, step.$arrayToObject, context) : "$map" in step ? applyMap(value, step.$map) : "$reduce" in step ? applyReduce(value, step.$reduce) : "$replace" in step ? applyReplace(value, step.$replace) : "$partition" in step ? applyPartition(value, step.$partition) : "$extract" in step ? applyExtract(value, step.$extract) : "$mapValues" in step ? applyMapValues(value, step.$mapValues, context) : "$mergeFields" in step ? applyMergeFields(value, step.$mergeFields) : value;
+}
+function applyFilter(value, config) {
+  if (typeof value != "object" || value === null)
+    return value;
+  let result = {}, match = config.match || {};
+  for (let [key, val] of Object.entries(value)) {
+    let keep = !0;
+    "value" in match && val !== match.value && (keep = !1), "key" in match && key !== match.key && (keep = !1), keep && (result[key] = val);
+  }
+  return result;
+}
+function applyObjectToArray(value, config) {
+  if (typeof value != "object" || value === null)
+    return [];
+  if (config === !0)
+    return Object.entries(value);
+  switch (config.extract || "entries") {
+    case "keys":
+      return Object.keys(value);
+    case "values":
+      return Object.values(value);
+    case "entries":
+      return Object.entries(value);
+    default:
+      return Object.entries(value);
+  }
+}
+function applyArrayToObject(value, config, context) {
+  if (!Array.isArray(value))
+    return value;
+  let resolvedValue = resolveValue(config.value, context), result = {};
+  for (let key of value)
+    typeof key == "string" && (result[key] = resolvedValue);
+  return result;
+}
+function applyMap(value, config) {
+  return Array.isArray(value) ? value.map((item) => {
+    if (typeof item != "string")
+      return item;
+    if (config.replace)
+      return config.replace[item] || item;
+    if (config.each)
+      switch (config.each) {
+        case "capitalize":
+          return item.charAt(0).toUpperCase() + item.slice(1);
+        case "uppercase":
+          return item.toUpperCase();
+        case "lowercase":
+          return item.toLowerCase();
+        default:
+          return item;
+      }
+    return item;
+  }) : value;
+}
+function applyReduce(value, config) {
+  let { type, separator = "" } = config;
+  switch (type) {
+    case "join":
+      return Array.isArray(value) ? value.join(separator) : value;
+    case "split":
+      return typeof value != "string" ? value : value.split(separator).map((s) => s.trim()).filter((s) => s.length > 0);
+    case "sum":
+      return Array.isArray(value) ? value.reduce((sum, n) => sum + (Number(n) || 0), 0) : value;
+    case "count":
+      return Array.isArray(value) ? value.length : 0;
+    default:
+      return value;
+  }
+}
+function applyReplace(value, config) {
+  if (typeof value != "string")
+    return value;
+  let flags = config.flags || "", regex = new RegExp(config.pattern, flags);
+  return value.replace(regex, config.with);
+}
+function applyPartition(value, config) {
+  if (typeof value != "object" || value === null)
+    return value;
+  let result = {};
+  for (let [entryKey, entryValue] of Object.entries(value)) {
+    let testValue = config.by === "value" ? String(entryValue) : entryKey;
+    for (let [bucketName, pattern] of Object.entries(config.patterns))
+      if (new RegExp(pattern).test(testValue)) {
+        result[bucketName] || (result[bucketName] = {}), result[bucketName][entryKey] = entryValue;
+        break;
+      }
+  }
+  return result;
+}
+function applyExtract(value, config) {
+  if (typeof value != "string")
+    return value;
+  let regex = new RegExp(config.pattern), match = value.match(regex);
+  return match ? match[config.group] : config.default === "$SELF" ? value : config.default !== void 0 ? config.default : value;
+}
+function applyMapValues(value, config, context) {
+  if (typeof value != "object" || value === null)
+    return value;
+  let result = {};
+  for (let [key, val] of Object.entries(value)) {
+    let transformedValue = val;
+    for (let step of config.operations)
+      transformedValue = applyPipelineStep(transformedValue, step, context);
+    result[key] = transformedValue;
+  }
+  return result;
+}
+function applyMergeFields(value, config) {
+  if (typeof value != "object" || value === null)
+    return value;
+  let result = { ...value }, merged = {};
+  for (let sourceKey of config.from)
+    if (sourceKey in result) {
+      let sourceValue = result[sourceKey];
+      typeof sourceValue == "object" && sourceValue !== null && Object.assign(merged, sourceValue), config.remove !== !1 && delete result[sourceKey];
+    }
+  return Object.keys(merged).length > 0 && (result[config.to] = merged), result;
+}
+function validatePipeline(operation) {
+  let errors = [];
+  if (!operation.$pipeline || typeof operation.$pipeline != "object")
+    return errors.push("$pipeline must be an object"), { valid: !1, errors };
+  let config = operation.$pipeline;
+  if ((!config.field || typeof config.field != "string") && errors.push("$pipeline.field must be a non-empty string"), !config.operations || !Array.isArray(config.operations))
+    return errors.push("$pipeline.operations must be an array"), { valid: errors.length === 0, errors };
+  config.operations.length === 0 && errors.push("$pipeline.operations must have at least one operation");
+  for (let i = 0; i < config.operations.length; i++) {
+    let step = config.operations[i];
+    if (!step || typeof step != "object") {
+      errors.push(`$pipeline.operations[${i}] must be an object`);
+      continue;
+    }
+    let stepKeys = Object.keys(step);
+    if (stepKeys.length !== 1) {
+      errors.push(`$pipeline.operations[${i}] must have exactly one operation`);
+      continue;
+    }
+    let operation2 = stepKeys[0], validOps = [
+      "$filter",
+      "$objectToArray",
+      "$arrayToObject",
+      "$map",
+      "$reduce",
+      "$replace",
+      "$partition",
+      "$extract",
+      "$mapValues",
+      "$mergeFields"
+    ];
+    if (validOps.includes(operation2) || errors.push(
+      `$pipeline.operations[${i}] has unknown operation "${operation2}". Valid: ${validOps.join(", ")}`
+    ), operation2 === "$filter") {
+      let filterConfig = step.$filter;
+      filterConfig && typeof filterConfig == "object" && filterConfig.match && typeof filterConfig.match != "object" && errors.push(`$pipeline.operations[${i}].$filter.match must be an object`);
+    }
+    if (operation2 === "$objectToArray") {
+      let config2 = step.$objectToArray;
+      if (config2 !== !0 && typeof config2 != "object")
+        errors.push(`$pipeline.operations[${i}].$objectToArray must be true or an object`);
+      else if (typeof config2 == "object" && config2.extract) {
+        let validExtracts = ["keys", "values", "entries"];
+        validExtracts.includes(config2.extract) || errors.push(
+          `$pipeline.operations[${i}].$objectToArray.extract must be one of: ${validExtracts.join(", ")}`
+        );
+      }
+    }
+    if (operation2 === "$arrayToObject") {
+      let config2 = step.$arrayToObject;
+      !config2 || typeof config2 != "object" ? errors.push(`$pipeline.operations[${i}].$arrayToObject must be an object`) : "value" in config2 || errors.push(`$pipeline.operations[${i}].$arrayToObject must have a 'value' property`);
+    }
+    if (operation2 === "$map") {
+      let config2 = step.$map;
+      if (!config2 || typeof config2 != "object")
+        errors.push(`$pipeline.operations[${i}].$map must be an object`);
+      else {
+        let hasEach = "each" in config2, hasReplace = "replace" in config2;
+        if (!hasEach && !hasReplace)
+          errors.push(`$pipeline.operations[${i}].$map must have either 'each' or 'replace' property`);
+        else if (hasEach && hasReplace)
+          errors.push(`$pipeline.operations[${i}].$map cannot have both 'each' and 'replace' properties`);
+        else if (hasEach) {
+          let validMaps = ["capitalize", "uppercase", "lowercase"];
+          validMaps.includes(config2.each) || errors.push(
+            `$pipeline.operations[${i}].$map.each must be one of: ${validMaps.join(", ")}`
+          );
+        } else hasReplace && (typeof config2.replace != "object" || config2.replace === null || Array.isArray(config2.replace) ? errors.push(`$pipeline.operations[${i}].$map.replace must be an object (lookup table)`) : Object.keys(config2.replace).length === 0 && errors.push(`$pipeline.operations[${i}].$map.replace must have at least one mapping`));
+      }
+    }
+    if (operation2 === "$reduce") {
+      let config2 = step.$reduce;
+      if (!config2 || typeof config2 != "object")
+        errors.push(`$pipeline.operations[${i}].$reduce must be an object`);
+      else if (!config2.type)
+        errors.push(`$pipeline.operations[${i}].$reduce must have a 'type' property`);
+      else {
+        let validTypes = ["join", "split", "sum", "count"];
+        validTypes.includes(config2.type) || errors.push(
+          `$pipeline.operations[${i}].$reduce.type must be one of: ${validTypes.join(", ")}`
+        ), (config2.type === "join" || config2.type === "split") && config2.separator !== void 0 && typeof config2.separator != "string" && errors.push(`$pipeline.operations[${i}].$reduce.separator must be a string`);
+      }
+    }
+    if (operation2 === "$replace") {
+      let config2 = step.$replace;
+      !config2 || typeof config2 != "object" ? errors.push(`$pipeline.operations[${i}].$replace must be an object`) : (typeof config2.pattern != "string" && errors.push(`$pipeline.operations[${i}].$replace.pattern must be a string`), typeof config2.with != "string" && errors.push(`$pipeline.operations[${i}].$replace.with must be a string`), config2.flags !== void 0 && typeof config2.flags != "string" && errors.push(`$pipeline.operations[${i}].$replace.flags must be a string`));
+    }
+    if (operation2 === "$partition") {
+      let config2 = step.$partition;
+      !config2 || typeof config2 != "object" ? errors.push(`$pipeline.operations[${i}].$partition must be an object`) : ((!config2.by || !["value", "key"].includes(config2.by)) && errors.push(`$pipeline.operations[${i}].$partition.by must be "value" or "key"`), !config2.patterns || typeof config2.patterns != "object" ? errors.push(`$pipeline.operations[${i}].$partition.patterns must be an object`) : Object.keys(config2.patterns).length === 0 && errors.push(`$pipeline.operations[${i}].$partition.patterns must have at least one pattern`));
+    }
+    if (operation2 === "$extract") {
+      let config2 = step.$extract;
+      !config2 || typeof config2 != "object" ? errors.push(`$pipeline.operations[${i}].$extract must be an object`) : (typeof config2.pattern != "string" && errors.push(`$pipeline.operations[${i}].$extract.pattern must be a string`), typeof config2.group != "number" && errors.push(`$pipeline.operations[${i}].$extract.group must be a number`));
+    }
+    if (operation2 === "$mapValues") {
+      let config2 = step.$mapValues;
+      !config2 || typeof config2 != "object" ? errors.push(`$pipeline.operations[${i}].$mapValues must be an object`) : Array.isArray(config2.operations) ? config2.operations.length === 0 && errors.push(`$pipeline.operations[${i}].$mapValues.operations must have at least one operation`) : errors.push(`$pipeline.operations[${i}].$mapValues.operations must be an array`);
+    }
+    if (operation2 === "$mergeFields") {
+      let config2 = step.$mergeFields;
+      !config2 || typeof config2 != "object" ? errors.push(`$pipeline.operations[${i}].$mergeFields must be an object`) : ((!Array.isArray(config2.from) || config2.from.length === 0) && errors.push(`$pipeline.operations[${i}].$mergeFields.from must be a non-empty array`), typeof config2.to != "string" && errors.push(`$pipeline.operations[${i}].$mergeFields.to must be a string`));
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// ../core/src/core/flows/map-pipeline/operations/copy.ts
+function executeCopy(document, operation) {
+  let result = { ...document }, { from, to, transform } = operation.$copy, sourceValue = getNestedValue(result, from);
+  if (sourceValue === void 0)
+    return result;
+  let targetValue = sourceValue;
+  return transform && (targetValue = applyTransform(sourceValue, transform)), setNestedValue(result, to, targetValue), result;
+}
+function applyTransform(value, transform) {
+  for (let { pattern, value: caseValue } of transform.cases)
+    if (matchPattern(value, pattern))
+      return caseValue;
+  return transform.default !== void 0 ? transform.default : value;
+}
+function validateCopy(operation) {
+  let errors = [];
+  if (!operation.$copy || typeof operation.$copy != "object")
+    return errors.push("$copy must be an object"), { valid: !1, errors };
+  let config = operation.$copy;
+  if ((!config.from || typeof config.from != "string") && errors.push("$copy.from must be a non-empty string"), (!config.to || typeof config.to != "string") && errors.push("$copy.to must be a non-empty string"), config.transform) {
+    if (typeof config.transform != "object")
+      return errors.push("$copy.transform must be an object"), { valid: errors.length === 0, errors };
+    if (!config.transform.cases || !Array.isArray(config.transform.cases))
+      errors.push("$copy.transform.cases must be an array");
+    else {
+      config.transform.cases.length === 0 && errors.push("$copy.transform.cases must have at least one case");
+      for (let i = 0; i < config.transform.cases.length; i++) {
+        let caseItem = config.transform.cases[i];
+        if (!caseItem || typeof caseItem != "object") {
+          errors.push(`$copy.transform.cases[${i}] must be an object`);
+          continue;
+        }
+        "pattern" in caseItem || errors.push(`$copy.transform.cases[${i}] must have a "pattern" field`), "value" in caseItem || errors.push(`$copy.transform.cases[${i}] must have a "value" field`);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// ../core/src/core/flows/map-pipeline/operations/pipe.ts
+function executePipe(document, operation, transformRegistry) {
+  let result = document;
+  for (let transformName of operation.$pipe)
+    try {
+      result = transformRegistry.execute(transformName, result);
+    } catch (error) {
+      throw new Error(
+        `$pipe transform '${transformName}' failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  return result;
+}
+function validatePipe(operation) {
+  let errors = [];
+  if (!operation.$pipe)
+    return errors.push("$pipe must be defined"), { valid: !1, errors };
+  if (!Array.isArray(operation.$pipe))
+    return errors.push("$pipe must be an array of transform names"), { valid: !1, errors };
+  operation.$pipe.length === 0 && errors.push("$pipe must have at least one transform");
+  for (let i = 0; i < operation.$pipe.length; i++) {
+    let transformName = operation.$pipe[i];
+    typeof transformName != "string" ? errors.push(`$pipe[${i}] must be a string (transform name)`) : (!transformName || transformName.trim() === "") && errors.push(`$pipe[${i}] transform name cannot be empty`);
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// ../core/src/core/flows/map-pipeline/index.ts
+function applyMapPipeline(document, pipeline, context, transformRegistry) {
+  let result = deepClone(document);
+  for (let operation of pipeline)
+    result = executeOperation(result, operation, context, transformRegistry);
+  return result;
+}
+function executeOperation(document, operation, context, transformRegistry) {
+  if ("$set" in operation)
+    return executeSet(document, operation, context);
+  if ("$rename" in operation)
+    return executeRename(document, operation);
+  if ("$unset" in operation)
+    return executeUnset(document, operation);
+  if ("$switch" in operation)
+    return executeSwitch(document, operation);
+  if ("$pipeline" in operation)
+    return executePipeline(document, operation, context);
+  if ("$copy" in operation)
+    return executeCopy(document, operation);
+  if ("$pipe" in operation) {
+    if (!transformRegistry)
+      throw new Error("$pipe operation requires transform registry to be provided");
+    return executePipe(document, operation, transformRegistry);
+  }
+  return document;
+}
+function validateMapPipeline(pipeline) {
+  let errors = [];
+  if (!Array.isArray(pipeline))
+    return {
+      valid: !1,
+      errors: ["Map pipeline must be an array"]
+    };
+  if (pipeline.length === 0)
+    return {
+      valid: !1,
+      errors: ["Map pipeline must have at least one operation"]
+    };
+  for (let i = 0; i < pipeline.length; i++) {
+    let operation = pipeline[i];
+    if (!operation || typeof operation != "object") {
+      errors.push(`Operation at index ${i} must be an object`);
+      continue;
+    }
+    let operationKeys = Object.keys(operation), validOperations = ["$set", "$rename", "$unset", "$switch", "$pipeline", "$copy", "$pipe"], operationKey = operationKeys.find((key) => validOperations.includes(key));
+    if (!operationKey) {
+      errors.push(
+        `Operation at index ${i} must have one of: ${validOperations.join(", ")}`
+      );
+      continue;
+    }
+    if (operationKeys.length > 1) {
+      errors.push(
+        `Operation at index ${i} must have exactly one operation (found: ${operationKeys.join(", ")})`
+      );
+      continue;
+    }
+    let validation = validateOperation(operation);
+    validation.valid || errors.push(
+      `Operation at index ${i} (${operationKey}): ${validation.errors.join(", ")}`
+    );
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateOperation(operation) {
+  return "$set" in operation ? validateSet(operation) : "$rename" in operation ? validateRename(operation) : "$unset" in operation ? validateUnset(operation) : "$switch" in operation ? validateSwitch(operation) : "$pipeline" in operation ? validatePipeline(operation) : "$copy" in operation ? validateCopy(operation) : "$pipe" in operation ? validatePipe(operation) : {
+    valid: !1,
+    errors: ["Unknown operation type"]
+  };
+}
+function splitMapPipeline(pipeline) {
+  let schemaOps = [], pipeOps = [];
+  for (let op of pipeline)
+    op && typeof op == "object" && "$pipe" in op ? pipeOps.push(op) : schemaOps.push(op);
+  return { schemaOps, pipeOps };
+}
+function createMapContext(options) {
+  return {
+    filename: options.filename,
+    dirname: options.dirname,
+    path: options.path,
+    ext: options.ext
+  };
+}
+
+// ../core/src/core/flows/flow-transforms.ts
+import yaml from "js-yaml";
+import * as TOML from "smol-toml";
+var TransformRegistry = class {
+  constructor() {
+    this.transforms = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a transform
+   */
+  register(transform) {
+    this.transforms.set(transform.name, transform);
+  }
+  /**
+   * Get a transform by name
+   */
+  get(name) {
+    return this.transforms.get(name);
+  }
+  /**
+   * Check if transform exists
+   */
+  has(name) {
+    return this.transforms.has(name);
+  }
+  /**
+   * Execute a transform by name
+   */
+  execute(name, input, options) {
+    let transform = this.get(name);
+    if (!transform)
+      throw new Error(`Transform not found: ${name}`);
+    if (transform.validate && !transform.validate(options))
+      throw new Error(`Invalid options for transform: ${name}`);
+    return transform.execute(input, options);
+  }
+  /**
+   * List all registered transform names
+   */
+  list() {
+    return Array.from(this.transforms.keys());
+  }
+}, jsoncTransform = {
+  name: "jsonc",
+  execute(input) {
+    if (typeof input != "string")
+      return input;
+    let stripped = input.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(stripped);
+  }
+}, yamlTransform = {
+  name: "yaml",
+  execute(input, options) {
+    return (options?.direction || "parse") === "parse" ? typeof input != "string" ? input : yaml.load(input) : yaml.dump(input, {
+      indent: 2,
+      flowLevel: 1,
+      // Use compact flow style for arrays
+      lineWidth: -1,
+      // Disable line wrapping
+      noRefs: !0
+      // Disable anchors/aliases
+    });
+  }
+}, tomlTransform = {
+  name: "toml",
+  execute(input, options) {
+    if ((options?.direction || "parse") === "parse") {
+      if (typeof input != "string")
+        return input;
+      try {
+        return TOML.parse(input);
+      } catch (error) {
+        throw new Error(`TOML parse error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    } else
+      try {
+        return TOML.stringify(input);
+      } catch (error) {
+        throw new Error(`TOML stringify error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+  }
+}, jsonToTomlTransform = {
+  name: "json-to-toml",
+  execute(input) {
+    return tomlTransform.execute(input, { direction: "stringify" });
+  }
+}, tomlToJsonTransform = {
+  name: "toml-to-json",
+  execute(input) {
+    return tomlTransform.execute(input, { direction: "parse" });
+  }
+}, filterCommentsTransform = {
+  name: "filter-comments",
+  execute(input) {
+    return typeof input != "string" ? input : input.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/^\s*#.*$/gm, "");
+  }
+}, filterEmptyTransform = {
+  name: "filter-empty",
+  execute(input, options) {
+    let recursive = options?.recursive ?? !0;
+    if (Array.isArray(input))
+      return input.filter((item) => !(item === "" || Array.isArray(item) && item.length === 0 || typeof item == "object" && item !== null && Object.keys(item).length === 0)).map((item) => recursive && typeof item == "object" ? filterEmptyTransform.execute(item, options) : item);
+    if (typeof input == "object" && input !== null) {
+      let filtered = {};
+      for (let [key, value] of Object.entries(input))
+        value === "" || Array.isArray(value) && value.length === 0 || typeof value == "object" && value !== null && Object.keys(value).length === 0 || (filtered[key] = recursive && typeof value == "object" ? filterEmptyTransform.execute(value, options) : value);
+      return filtered;
+    }
+    return input;
+  }
+}, filterNullTransform = {
+  name: "filter-null",
+  execute(input, options) {
+    let recursive = options?.recursive ?? !0;
+    if (Array.isArray(input))
+      return input.filter((item) => item != null).map((item) => recursive && typeof item == "object" ? filterNullTransform.execute(item, options) : item);
+    if (typeof input == "object" && input !== null) {
+      let filtered = {};
+      for (let [key, value] of Object.entries(input))
+        value != null && (filtered[key] = recursive && typeof value == "object" ? filterNullTransform.execute(value, options) : value);
+      return filtered;
+    }
+    return input;
+  }
+}, sectionsTransform = {
+  name: "sections",
+  execute(input, options) {
+    if (typeof input != "string")
+      return { content: String(input) };
+    let level = options?.level || 1, headerRegex = new RegExp(`^#{${level}}\\s+(.+)$`, "gm"), sections = {}, lastIndex = 0, lastTitle = "_preamble", match;
+    for (; (match = headerRegex.exec(input)) !== null; )
+      lastIndex < match.index && (sections[lastTitle] = input.slice(lastIndex, match.index).trim()), lastTitle = match[1].trim(), lastIndex = match.index + match[0].length;
+    return lastIndex < input.length && (sections[lastTitle] = input.slice(lastIndex).trim()), sections;
+  }
+}, frontmatterTransform = {
+  name: "frontmatter",
+  execute(input) {
+    if (typeof input != "string")
+      return {};
+    let match = input.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+    if (!match)
+      return {};
+    try {
+      return yaml.load(match[1]) || {};
+    } catch (error) {
+      return logger.warn(`Failed to parse frontmatter: ${error}`), {};
+    }
+  }
+}, bodyTransform = {
+  name: "body",
+  execute(input) {
+    if (typeof input != "string")
+      return String(input);
+    let match = input.match(/^---\s*\n[\s\S]*?\n---\s*\n([\s\S]*)$/);
+    return match ? match[1].trim() : input.trim();
+  }
+}, numberTransform = {
+  name: "number",
+  execute(input) {
+    let num = Number(input);
+    if (isNaN(num))
+      throw new Error(`Cannot convert to number: ${input}`);
+    return num;
+  }
+}, stringTransform = {
+  name: "string",
+  execute(input) {
+    return String(input);
+  }
+}, booleanTransform = {
+  name: "boolean",
+  execute(input) {
+    if (typeof input == "boolean") return input;
+    if (typeof input == "string") {
+      let lower = input.toLowerCase();
+      if (lower === "true" || lower === "1" || lower === "yes") return !0;
+      if (lower === "false" || lower === "0" || lower === "no") return !1;
+    }
+    return !!input;
+  }
+}, jsonTransform = {
+  name: "json",
+  execute(input) {
+    return typeof input == "string" ? JSON.parse(input) : input;
+  }
+}, dateTransform = {
+  name: "date",
+  execute(input) {
+    let date = new Date(input);
+    if (isNaN(date.getTime()))
+      throw new Error(`Cannot convert to date: ${input}`);
+    return date;
+  }
+}, uppercaseTransform = {
+  name: "uppercase",
+  execute(input) {
+    return String(input).toUpperCase();
+  }
+}, lowercaseTransform = {
+  name: "lowercase",
+  execute(input) {
+    return String(input).toLowerCase();
+  }
+}, trimTransform = {
+  name: "trim",
+  execute(input) {
+    return String(input).trim();
+  }
+}, titleCaseTransform = {
+  name: "title-case",
+  execute(input) {
+    return String(input).toLowerCase().split(/\s+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+}, camelCaseTransform = {
+  name: "camel-case",
+  execute(input) {
+    return String(input).replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^(.)/, (_, c) => c.toLowerCase());
+  }
+}, kebabCaseTransform = {
+  name: "kebab-case",
+  execute(input) {
+    return String(input).replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+  }
+}, snakeCaseTransform = {
+  name: "snake-case",
+  execute(input) {
+    return String(input).replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+  }
+}, slugifyTransform = {
+  name: "slugify",
+  execute(input) {
+    return String(input).toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "");
+  }
+}, arrayAppendTransform = {
+  name: "array-append",
+  execute(input, options) {
+    return [...Array.isArray(input) ? input : [input], options?.value];
+  }
+}, arrayUniqueTransform = {
+  name: "array-unique",
+  execute(input) {
+    return Array.isArray(input) ? [...new Set(input)] : [input];
+  }
+}, arrayFlattenTransform = {
+  name: "array-flatten",
+  execute(input, options) {
+    if (!Array.isArray(input))
+      return [input];
+    let depth = options?.depth ?? 1 / 0;
+    return input.flat(depth);
+  }
+}, flattenTransform = {
+  name: "flatten",
+  execute(input, options) {
+    if (typeof input != "object" || input === null)
+      return { value: input };
+    let separator = options?.separator || ".", result = {};
+    function flatten(obj, prefix = "") {
+      for (let [key, value] of Object.entries(obj)) {
+        let newKey = prefix ? `${prefix}${separator}${key}` : key;
+        typeof value == "object" && value !== null && !Array.isArray(value) ? flatten(value, newKey) : result[newKey] = value;
+      }
+    }
+    return flatten(input), result;
+  }
+}, unflattenTransform = {
+  name: "unflatten",
+  execute(input, options) {
+    if (typeof input != "object" || input === null)
+      return input;
+    let separator = options?.separator || ".", result = {};
+    for (let [path, value] of Object.entries(input)) {
+      let keys = path.split(separator), current = result;
+      for (let i = 0; i < keys.length - 1; i++) {
+        let key = keys[i];
+        key in current || (current[key] = {}), current = current[key];
+      }
+      current[keys[keys.length - 1]] = value;
+    }
+    return result;
+  }
+}, pickKeysTransform = {
+  name: "pick-keys",
+  execute(input, options) {
+    if (typeof input != "object" || input === null)
+      return input;
+    let keys = options?.keys || [], result = {};
+    for (let key of keys)
+      key in input && (result[key] = input[key]);
+    return result;
+  },
+  validate(options) {
+    return Array.isArray(options?.keys);
+  }
+}, omitKeysTransform = {
+  name: "omit-keys",
+  execute(input, options) {
+    if (typeof input != "object" || input === null)
+      return input;
+    let keys = options?.keys || [], result = { ...input };
+    for (let key of keys)
+      delete result[key];
+    return result;
+  },
+  validate(options) {
+    return Array.isArray(options?.keys);
+  }
+}, validateTransform = {
+  name: "validate",
+  execute(input, options) {
+    if (typeof input != "object" || input === null)
+      throw new Error("Validation failed: input must be an object");
+    let missing = (options?.required || []).filter((key) => !(key in input));
+    if (missing.length > 0)
+      throw new Error(`Validation failed: missing required keys: ${missing.join(", ")}`);
+    return input;
+  }
+};
+function createDefaultTransformRegistry() {
+  let registry = new TransformRegistry();
+  return registry.register(jsoncTransform), registry.register(yamlTransform), registry.register(tomlTransform), registry.register(jsonToTomlTransform), registry.register(tomlToJsonTransform), registry.register(filterCommentsTransform), registry.register(filterEmptyTransform), registry.register(filterNullTransform), registry.register(sectionsTransform), registry.register(frontmatterTransform), registry.register(bodyTransform), registry.register(numberTransform), registry.register(stringTransform), registry.register(booleanTransform), registry.register(jsonTransform), registry.register(dateTransform), registry.register(uppercaseTransform), registry.register(lowercaseTransform), registry.register(trimTransform), registry.register(titleCaseTransform), registry.register(camelCaseTransform), registry.register(kebabCaseTransform), registry.register(snakeCaseTransform), registry.register(slugifyTransform), registry.register(arrayAppendTransform), registry.register(arrayUniqueTransform), registry.register(arrayFlattenTransform), registry.register(flattenTransform), registry.register(unflattenTransform), registry.register(pickKeysTransform), registry.register(omitKeysTransform), registry.register(validateTransform), registry;
+}
+var defaultTransformRegistry = createDefaultTransformRegistry();
+
+// ../core/src/core/flows/markdown.ts
+import yaml2 from "js-yaml";
+function parseMarkdownDocument(content, options) {
+  let frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/, match = content.match(frontmatterRegex);
+  if (!match)
+    return { body: content };
+  let [, frontmatterRaw, body] = match;
+  try {
+    return { frontmatter: yaml2.load(frontmatterRaw) ?? {}, body };
+  } catch (error) {
+    if (options?.lenient)
+      return { body: content };
+    throw error;
+  }
+}
+function serializeMarkdownDocument(content) {
+  if (typeof content == "string")
+    return content;
+  let body = typeof content?.body == "string" ? content.body : "";
+  return content && typeof content == "object" && "frontmatter" in content && content.frontmatter ? `---
+${yaml2.dump(content.frontmatter, {
+    indent: 2,
+    flowLevel: -1,
+    lineWidth: -1,
+    noRefs: !0
+  })}---
+
+${body}` : body;
+}
+
+export {
+  applyMapPipeline,
+  validateMapPipeline,
+  splitMapPipeline,
+  createMapContext,
+  defaultTransformRegistry,
+  parseMarkdownDocument,
+  serializeMarkdownDocument
+};
+//# sourceMappingURL=chunk-IXOEIRDT.js.map