anchor.diff:  	Filters2 = string:tokens(Filters1, ","),
   	Filters3 = [string:tokens(F, ".") || F <- Filters2],
   	Filters4 = lists:usort(Filters3),
  -	Fsort = fun(A, B) when length(A) =< length(B) ->
  -				true;
  -			(_, _) ->
  -				false
  -	end,
  -	Filters5 = lists:sort(Fsort, Filters4),
  -	filter1(Filters5, JsonObject, []).
  +	filter1(Filters4, JsonObject, []).
   
   -spec range(Range) -> Result
   	when
  
positive.code: %% 	Example:
  %% 	```
  %% 	1> In = {struct,[{"a",{array,[{struct,[{"name","bob"},{"value",6}]},
  %% 	1> {"b",7},{struct,[{"name","sue"},{"value",5}]}]}},{"b",1}]},
  %% 	1> ocs_rest:filter("b,a.name=sue", In).
  %% 	{struct, [{"a",{array,[{struct,[{"name","sue"},{"value",5}]}]}},{"b",1}]}
  %% 	'''
  %%
  
negative.code: %%----------------------------------------------------------------------
  
  %% @hidden
  filter1(Filters, {array, L}, Acc) ->
  	{array, filter2(Filters, L, Acc)};
  filter1(Filters, {struct, L}, Acc) ->
  	{struct, filter3(Filters, L, false, true, Acc)}.
  
  -spec filter2(Filters, Elements, Acc) -> Result
  	when
  		Filters :: [list(string())],
  		Elements :: [Value],
  		Value :: integer() | string() | {struct, Members} | {array, Elements},
  		Members :: [{Key, Value}],
  		Key :: string(),
  		Acc :: [Value],
  		Result :: [Value].
  %% @doc Process each array element.
  %% @hidden
  filter2(Filters, [{Type, Value} | T], Acc)
  		when Type == struct; Type == array ->
  	case filter1(Filters, {Type, Value}, []) of
  		{struct, []} ->
  			filter2(Filters, T, Acc);
  		Object ->
  			filter2(Filters, T, [Object | Acc])
  	end;
  filter2(Filters, [_ | T], Acc) ->
  	filter2(Filters, T, Acc);
  filter2(_, [], Acc) ->
  	lists:reverse(Acc).
  
  -spec filter3(Filters, Members, IsValueMatch, ValueMatched, Acc) -> Result
  	when
  		Filters :: [list(string())],
  		Members :: [{Key, Value}],
  		Key :: string(),
  		Value :: integer() | string() | {struct, Members} | {array, Elements},
  		Elements :: [Value],
  		IsValueMatch :: boolean(),
  		ValueMatched :: boolean(),
  		Acc :: [{Key, Value}],
  		Result :: [{Key, Value}].
  %% @doc Process each object member.
  %% @hidden
  filter3(Filters, [{Key1, Value1} | T], IsValueMatch, ValueMatched, Acc) ->
  	case filter4(Filters, {Key1, Value1}, false) of
  		{false, false} ->
  			filter3(Filters, T, IsValueMatch, ValueMatched, Acc);
  		{true, false} when IsValueMatch == false ->
  			filter3(Filters, T, true, false, Acc);
  		{true, false} ->
  			filter3(Filters, T, true, ValueMatched, Acc);
  		{false, {_, {_, []}}} ->
  			filter3(Filters, T, IsValueMatch, ValueMatched, Acc);
  		{false, {Key2, Value2}} ->
  			filter3(Filters, T, IsValueMatch, ValueMatched, [{Key2, Value2} | Acc]);
  		{true, {Key2, Value2}} ->
  			filter3(Filters, T, true, true, [{Key2, Value2} | Acc])
  	end;
  filter3(Filters, [H | T], IsValueMatch, ValueMatched, Acc) ->
  	filter3(Filters, T, IsValueMatch, ValueMatched, Acc);
  filter3(_, [], _, false, Acc) ->
  	[];
  filter3(_, [], _, true, Acc) ->
  	lists:reverse(Acc).
  
  -spec filter4(Filters, Member, IsValueMatch) -> Result
  	when
  		Filters :: [list(string())],
  		Member :: {Key, Value},
  		IsValueMatch :: boolean(),
  		Key :: string(),
  		Value :: integer() | string() | {struct, [Member]} | {array, [Value]},
  		Result :: {ValueMatch, MatchResult},
  		ValueMatch :: boolean(),
  		MatchResult :: false | Member.
  %% @doc Apply filters to an object member.
  %% @hidden
  filter4([[Key] | _], {Key, Value}, IsValueMatch) ->
  	{IsValueMatch, {Key, Value}};
  filter4([[S] | T], {Key, Value}, IsValueMatch) ->
  	case split(S) of
  		{Key, Value} ->
  			{true, {Key, Value}};
  		{Key, _} ->
  			filter4(T, {Key, Value}, true);
  		_ ->
  			filter4(T, {Key, Value}, IsValueMatch)
  	end;
  filter4([[Key | _ ] | _] = Filters1, {Key, {Type, L}}, IsValueMatch)
  		when Type == struct; Type == array ->
  	F1 = fun([K | _]) when K =:= Key ->
  				true;
  			(_) ->
  				false
  	end,
  	Filters2 = lists:takewhile(F1, Filters1),
  	F2 = fun([_ | T]) -> T end,
  	Filters3 = lists:map(F2, Filters2),
  	{IsValueMatch, {Key, filter1(Filters3, {Type, L}, [])}};
  filter4([_ | T] = Filters, {Key, Value}, IsValueMatch) ->
  	filter4(T, {Key, Value}, IsValueMatch);
  filter4([], _, IsValueMatch) ->
  	{IsValueMatch, false}.
  
  %% @hidden
  expand("=(" ++ T, Acc) ->
  	{Key, NewAcc} = expand1(Acc, []),
  	expand2(T, Key, [], NewAcc);
  