hunk.code_window:  * @deprecated Deprecated in favor of static {@link zip}.
    */
   export function zip<T, R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): OperatorFunction<T, R> {
     return function zipOperatorFunction(source: Observable<T>) {
       return source.lift.call(zipStatic<R>(source, ...observables));
     };
   }
  
hunk.labels: keep keep keep keep replace keep keep
hunk.after_edit:     return source.lift.call(
         zipStatic<R>(source, ...observables),
         undefined
       ) as Observable<R>;
  
hunk.file_path: src/internal/operators/zip.ts
hunk.type: replace
file: const testPackage = require('../../helpers/test-package');
  const processorFactory = require('./processClassLikeMembers');
  const Dgeni = require('dgeni');
  
  const property1 = { description: 'property 1' };
  const property2 = { description: 'property 2' };
  const getter1 = { parameters: [], isGetAccessor: true, description: 'getter 1' };
  const setter1 = { parameters: [], isSetAccessor: true, description: 'setter 1' };
  const method1 = { parameters: [] };
  const method2 = { parameters: [] };
  const method3 = { parameters: [] };
  
  describe('angular-api-package: processClassLikeMembers processor', () => {
  
    it('should be available on the injector', () => {
      const dgeni = new Dgeni([testPackage('angular-api-package')]);
      const injector = dgeni.configureInjector();
      const processor = injector.get('processClassLikeMembers');
      expect(processor.$process).toBeDefined();
      expect(processor.$runAfter).toEqual(['filterContainedDocs']);
      expect(processor.$runBefore).toEqual(['rendering-docs']);
    });
  
    it('should copy instance members into properties and methods', () => {
      const processor = processorFactory();
      const docs = [
        { members: [ property1, method1, getter1] },
        { members: [ method2, property2, method3, setter1] },
        { }
      ];
      processor.$process(docs);
  
      expect(docs[0].properties).toEqual([property1, getter1]);
      expect(docs[0].methods).toEqual([method1]);
  
      expect(docs[1].properties).toEqual([property2, setter1]);
      expect(docs[1].methods).toEqual([method2, method3]);
  
      expect(docs[2].properties).toBeUndefined();
      expect(docs[2].methods).toBeUndefined();
    });
  
    it('should copy static members into properties and methods', () => {
      const processor = processorFactory();
      const docs = [
        { statics: [ property1, method1, getter1] },
        { statics: [ method2, property2, method3, setter1] },
        { }
      ];
      processor.$process(docs);
  
      expect(docs[0].staticProperties).toEqual([property1, getter1]);
      expect(docs[0].staticMethods).toEqual([method1]);
  
      expect(docs[1].staticProperties).toEqual([property2, setter1]);
      expect(docs[1].staticMethods).toEqual([method2, method3]);
  
      expect(docs[2].staticProperties).toBeUndefined();
      expect(docs[2].staticMethods).toBeUndefined();
    });
  
    it('should wire up properties that are declared as parameters on the constructor to its associated parameter doc', () => {
      const processor = processorFactory();
      const propertyDeclaration = {};
      const parameterDoc1 = { declaration: {} };
      const parameterDoc2 = { declaration: propertyDeclaration };
      const parameterDoc3 = { declaration: {} };
      const property = {
        declaration: propertyDeclaration,
        containerDoc: {
          constructorDoc: {
            parameterDocs: [ parameterDoc1, parameterDoc2, parameterDoc3 ]
          }
        }
      };
      const docs = [{ members: [ property] }];
      processor.$process(docs);
  
      expect(property.constructorParamDoc).toEqual(parameterDoc2);
    });
  });
  