mlld/dist/chunk-3BKXIDNI.mjs

mlld: a modular prompt scripting language

import { isVariable } from './chunk-7ASO6AZA.mjs';
import { __name } from './chunk-OMKLS24H.mjs';

// interpreter/env/variable-proxy.ts
var VARIABLE_PROXY_PROPS = {
  TYPE: "__mlld_type",
  SUBTYPE: "__mlld_subtype",
  METADATA: "__mlld_metadata",
  VARIABLE: "__mlld_variable",
  IS_VARIABLE: "__mlld_is_variable"
};
function createVariableProxy(variable) {
  const value = variable.value;
  if (value === null || typeof value !== "object") {
    return value;
  }
  return new Proxy(value, {
    get(target, prop, receiver) {
      switch (prop) {
        case VARIABLE_PROXY_PROPS.TYPE:
          return variable.type;
        case VARIABLE_PROXY_PROPS.SUBTYPE:
          return variable.subtype;
        case VARIABLE_PROXY_PROPS.METADATA:
          return variable.metadata || {};
        case VARIABLE_PROXY_PROPS.VARIABLE:
          return variable;
        case VARIABLE_PROXY_PROPS.IS_VARIABLE:
          return true;
        // Special handling for toString to preserve custom behavior
        case "toString":
          if (variable.metadata?.customToString) {
            return variable.metadata.customToString.bind(target);
          }
          return Reflect.get(target, prop, receiver);
        // Special handling for toJSON
        case "toJSON":
          if (variable.metadata?.customToJSON) {
            return variable.metadata.customToJSON;
          }
          return Reflect.get(target, prop, receiver);
        default:
          return Reflect.get(target, prop, receiver);
      }
    },
    // Preserve normal array/object behavior for other operations
    set(target, prop, value2, receiver) {
      return Reflect.set(target, prop, value2, receiver);
    },
    has(target, prop) {
      if (Object.values(VARIABLE_PROXY_PROPS).includes(prop)) {
        return true;
      }
      return Reflect.has(target, prop);
    },
    ownKeys(target) {
      return Reflect.ownKeys(target);
    },
    getOwnPropertyDescriptor(target, prop) {
      if (Object.values(VARIABLE_PROXY_PROPS).includes(prop)) {
        return {
          configurable: true,
          enumerable: false,
          get: /* @__PURE__ */ __name(() => this.get(target, prop, target), "get")
        };
      }
      return Reflect.getOwnPropertyDescriptor(target, prop);
    }
  });
}
__name(createVariableProxy, "createVariableProxy");
function prepareValueForShadow(value) {
  if (isVariable(value)) {
    return createVariableProxy(value);
  }
  return value;
}
__name(prepareValueForShadow, "prepareValueForShadow");
function prepareParamsForShadow(params) {
  const shadowParams = {};
  for (const [key, value] of Object.entries(params)) {
    shadowParams[key] = prepareValueForShadow(value);
  }
  return shadowParams;
}
__name(prepareParamsForShadow, "prepareParamsForShadow");
function isVariableProxy(value) {
  if (value === null || typeof value !== "object") {
    return false;
  }
  try {
    return value[VARIABLE_PROXY_PROPS.IS_VARIABLE] === true;
  } catch {
    return false;
  }
}
__name(isVariableProxy, "isVariableProxy");
function getVariableType(value) {
  if (!isVariableProxy(value)) {
    return void 0;
  }
  try {
    return value[VARIABLE_PROXY_PROPS.TYPE];
  } catch {
    return void 0;
  }
}
__name(getVariableType, "getVariableType");
function createMlldHelpers(primitiveMetadata) {
  return {
    // Type checking - also check primitive metadata
    isVariable: /* @__PURE__ */ __name((value, name) => {
      if (isVariableProxy(value)) {
        return true;
      }
      if (name && primitiveMetadata && primitiveMetadata[name]) {
        return primitiveMetadata[name].isVariable === true;
      }
      return false;
    }, "isVariable"),
    getType: /* @__PURE__ */ __name((value, name) => {
      const proxyType = getVariableType(value);
      if (proxyType !== void 0) {
        return proxyType;
      }
      if (name && primitiveMetadata && primitiveMetadata[name]) {
        return primitiveMetadata[name].type;
      }
      return void 0;
    }, "getType"),
    // Property names for direct access
    TYPE: VARIABLE_PROXY_PROPS.TYPE,
    SUBTYPE: VARIABLE_PROXY_PROPS.SUBTYPE,
    METADATA: VARIABLE_PROXY_PROPS.METADATA,
    VARIABLE: VARIABLE_PROXY_PROPS.VARIABLE,
    // Metadata helpers - also check primitive metadata
    getMetadata: /* @__PURE__ */ __name((value, name) => {
      if (isVariableProxy(value)) {
        try {
          return value[VARIABLE_PROXY_PROPS.METADATA];
        } catch {
          return void 0;
        }
      }
      if (name && primitiveMetadata && primitiveMetadata[name]) {
        return primitiveMetadata[name].metadata || {};
      }
      return void 0;
    }, "getMetadata"),
    // Get subtype - also check primitive metadata
    getSubtype: /* @__PURE__ */ __name((value, name) => {
      if (isVariableProxy(value)) {
        try {
          return value[VARIABLE_PROXY_PROPS.SUBTYPE];
        } catch {
          return void 0;
        }
      }
      if (name && primitiveMetadata && primitiveMetadata[name]) {
        return primitiveMetadata[name].subtype;
      }
      return void 0;
    }, "getSubtype"),
    // Get the full Variable object - or reconstruct from metadata
    getVariable: /* @__PURE__ */ __name((value, name) => {
      if (isVariableProxy(value)) {
        try {
          return value[VARIABLE_PROXY_PROPS.VARIABLE];
        } catch {
          return void 0;
        }
      }
      if (name && primitiveMetadata && primitiveMetadata[name]) {
        const meta = primitiveMetadata[name];
        return {
          name,
          value,
          type: meta.type,
          subtype: meta.subtype,
          metadata: meta.metadata,
          isVariable: true
        };
      }
      return void 0;
    }, "getVariable")
  };
}
__name(createMlldHelpers, "createMlldHelpers");

export { createMlldHelpers, prepareParamsForShadow, prepareValueForShadow };
//# sourceMappingURL=chunk-3BKXIDNI.mjs.map
//# sourceMappingURL=chunk-3BKXIDNI.mjs.map