Exported shader's output is black

I am developing an application which can export unity shader files (.shader), depending on the user's input. At this moment, I have accomplished that the shader is correctly exported (if I use it in the main project), but when using that shader in a separate project, its output is unlit pitch black, although it does not show any errors.

I'm out of ideas about where am I failing to initialize the shader, or if I am missing something. Any help is heavily appreciated, I've tried to solve it during the last months, to no avail.

The build of the application is here., if you want to try another examples (the shaders can be lit or unlit, depending on the user's input).

"You can create a shader by clicking the desired options, then "Save Shader", and then choose the desired folder to export. "

The code of the output shader is the following. You can just copy/paste it to a new .shader file, and assign it to a material:

 Shader"Shaderonomicon/New Shader"  
 {
     
  SubShader 
  { 
   Blend SrcAlpha OneMinusSrcAlpha  
  Pass 
 { 
  Tags { "Queue" = "Transparent" }   
  LOD 100 
 CGPROGRAM
   #pragma vertex vert_PerPixelLighting_NoTextureNoNormalMap  
   #pragma fragment frag_PerPixelLighting_Lambert_NoTextureNoNormalMap  
  #include "UnityCG.cginc"   
  #include "UnityLightingCommon.cginc"
      uniform fixed4 _TextureTint = float4(0.8312742 , 0.3925535 , 0.3925535 , 1 ) ; 
  uniform float _LambertTintForce = 0.9338841 ; 
  uniform float4 _LambertTintColor  = float4(0.5880297 , 0.3925535 , 0.8312742 , 1 ) ; 
  struct vertexInput_NoTextureNoNormalMap  {  float4 vertex : POSITION; 
  float3 normal : NORMAL; 
  }; 
  struct vertexOutput_NoTextureNoNormalMap_PerPixelLighting  {  float4 pos : SV_POSITION;  float3 posWorld : TEXCOORD0;  float3 normalDir : TEXCOORD1;  float3 normal : NORMAL;  }; 
  struct vertexOutput_NoNormalMap_PerPixelLighting 
  {  float4 pos : SV_POSITION; 
  float3 posWorld : TEXCOORD0; 
  float3 normalDir : TEXCOORD1; 
  float3 normal : NORMAL; 
  float2 tex : TEXCOORD2; 
  }; 
  float3 Lambert_Lighting_Pixel_NoNormalMap(vertexOutput_NoNormalMap_PerPixelLighting input) 
  {  float3 normalDirection = normalize(input.normalDir); 
  float3 viewDirection = normalize(_WorldSpaceCameraPos - input.posWorld.xyz); 
  float3 lightDirection; 
  float attenuation; 
  if (0.0 == _WorldSpaceLightPos0.w) 
  {  attenuation = 1.0f; 
  lightDirection = normalize(_WorldSpaceLightPos0.xyz); 
  }  else 
  {  float3 vertexToLightSource = _WorldSpaceLightPos0.xyz - input.posWorld.xyz; 
  float distance = length(vertexToLightSource); 
  attenuation = 1.0 / distance; 
  lightDirection = normalize(vertexToLightSource); 
  }  float NDotL = max(0.0, dot(normalDirection, lightDirection)); 
  float LambertDiffuse = NDotL; 
  float3 finalColor = LambertDiffuse * attenuation * _LightColor0.rgb; 
  return finalColor;  } 
  vertexOutput_NoTextureNoNormalMap_PerPixelLighting vert_PerPixelLighting_NoTextureNoNormalMap(vertexInput_NoTextureNoNormalMap input)
  {  vertexOutput_NoTextureNoNormalMap_PerPixelLighting output; 
  float4x4 modelMatrix = unity_ObjectToWorld; 
  float4x4 modelMatrixInverse = unity_WorldToObject; 
  output.posWorld = mul(modelMatrix, input.vertex); 
  output.normalDir = normalize(mul(float4(input.normal, 0.0), modelMatrixInverse).xyz); 
  output.normal = input.normal; 
  output.pos = UnityObjectToClipPos(input.vertex); 
  return output;  } 
  float4 frag_PerPixelLighting_Lambert_NoTextureNoNormalMap(vertexOutput_NoTextureNoNormalMap_PerPixelLighting input) : COLOR 
  {  vertexOutput_NoNormalMap_PerPixelLighting dummyOutput; 
  dummyOutput.posWorld = input.posWorld; 
  dummyOutput.normalDir = input.normalDir; 
  dummyOutput.normal = input.normal; 
  dummyOutput.pos = input.pos; 
  return float4 (Lambert_Lighting_Pixel_NoNormalMap(dummyOutput).xyz * (_LambertTintColor * _LambertTintForce).xyz * _TextureTint.xyz, 1.0); 
  } 
 
  ENDCG   
  }  }  }