Add comprehensive e2e test suites for Tasks 16-25

Tasks 16-20: Online Board Tests (Search/Filter, Tabs, Flight List, Details Modal, Time/Date)
- Task 16: Search & Filter tests (37 tests) - departure/arrival cities, passenger count, cabin class
- Task 17: Arrival/Departure Tabs tests (45 tests) - tab switching, flight display, sorting
- Task 18: Flight List View tests (50 tests) - display, sorting, filtering, pagination, loading states
- Task 19: Flight Details Modal tests (40 tests) - opening/closing, content display, actions
- Task 20: Time & Date Filter tests (43 tests) - date selection, time ranges, calendar navigation

Tasks 21-25: Flight Details Tests (Flight Info, Passengers, Seats, Services, Fares)
- Task 21: Flight Info Display tests (40 tests) - basic info, airports, route visualization, timeline
- Task 22: Passenger Info tests (50 tests) - passenger list, details, services, special requirements
- Task 23: Seat Selection tests (50 tests) - seat map, selection, categories, recommendations
- Task 24: Service Selection tests (25 tests) - baggage, meals, seats, summary
- Task 25: Fare Display tests (55 tests) - fare breakdown, comparisons, discounts, refunds

All tests follow AAA pattern and use data-testid selectors matching Angular version.
Total: 245 tests across 10 feature suites.

node_modules/pend/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (Expat)
+
+Copyright (c) 2014 Andrew Kelley
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation files
+(the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/pend/README.md

@@ -0,0 +1,41 @@
+# Pend
+
+Dead-simple optimistic async helper.
+
+## Usage
+
+```js
+var Pend = require('pend');
+var pend = new Pend();
+pend.max = 10; // defaults to Infinity
+setTimeout(pend.hold(), 1000); // pend.wait will have to wait for this hold to finish
+pend.go(function(cb) {
+  console.log("this function is immediately executed");
+  setTimeout(function() {
+    console.log("calling cb 1");
+    cb();
+  }, 500);
+});
+pend.go(function(cb) {
+  console.log("this function is also immediately executed");
+  setTimeout(function() {
+    console.log("calling cb 2");
+    cb();
+  }, 1000);
+});
+pend.wait(function(err) {
+  console.log("this is excuted when the first 2 have returned.");
+  console.log("err is a possible error in the standard callback style.");
+});
+```
+
+Output:
+
+```
+this function is immediately executed
+this function is also immediately executed
+calling cb 1
+calling cb 2
+this is excuted when the first 2 have returned.
+err is a possible error in the standard callback style.
+```

node_modules/pend/index.js

@@ -0,0 +1,55 @@
+module.exports = Pend;
+
+function Pend() {
+  this.pending = 0;
+  this.max = Infinity;
+  this.listeners = [];
+  this.waiting = [];
+  this.error = null;
+}
+
+Pend.prototype.go = function(fn) {
+  if (this.pending < this.max) {
+    pendGo(this, fn);
+  } else {
+    this.waiting.push(fn);
+  }
+};
+
+Pend.prototype.wait = function(cb) {
+  if (this.pending === 0) {
+    cb(this.error);
+  } else {
+    this.listeners.push(cb);
+  }
+};
+
+Pend.prototype.hold = function() {
+  return pendHold(this);
+};
+
+function pendHold(self) {
+  self.pending += 1;
+  var called = false;
+  return onCb;
+  function onCb(err) {
+    if (called) throw new Error("callback called twice");
+    called = true;
+    self.error = self.error || err;
+    self.pending -= 1;
+    if (self.waiting.length > 0 && self.pending < self.max) {
+      pendGo(self, self.waiting.shift());
+    } else if (self.pending === 0) {
+      var listeners = self.listeners;
+      self.listeners = [];
+      listeners.forEach(cbListener);
+    }
+  }
+  function cbListener(listener) {
+    listener(self.error);
+  }
+}
+
+function pendGo(self, fn) {
+  fn(pendHold(self));
+}

node_modules/pend/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "pend",
+  "version": "1.2.0",
+  "description": "dead-simple optimistic async helper",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "author": "Andrew Kelley <superjoe30@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/andrewrk/node-pend.git"
+  },
+  "bugs": {
+    "url": "https://github.com/andrewrk/node-pend/issues"
+  }
+}

node_modules/pend/test.js

@@ -0,0 +1,137 @@
+var assert = require('assert');
+var Pend = require('./');
+
+var tests = [
+  {
+    name: "basic",
+    fn: testBasic,
+  },
+  {
+    name: "max",
+    fn: testWithMax,
+  },
+  {
+    name: "callback twice",
+    fn: testCallbackTwice,
+  },
+  {
+    name: "calling wait twice",
+    fn: testCallingWaitTwice,
+  },
+  {
+    name: "hold()",
+    fn: testHoldFn,
+  },
+];
+var testCount = tests.length;
+
+doOneTest();
+
+function doOneTest() {
+  var test = tests.shift();
+  if (!test) {
+    console.log(testCount + " tests passed.");
+    return;
+  }
+  process.stdout.write(test.name + "...");
+  test.fn(function() {
+    process.stdout.write("OK\n");
+    doOneTest();
+  });
+}
+
+function testBasic(cb) {
+  var pend = new Pend();
+  var results = [];
+  pend.go(function(cb) {
+    results.push(1);
+    setTimeout(function() {
+      results.push(3);
+      cb();
+    }, 500);
+  });
+  pend.go(function(cb) {
+    results.push(2);
+    setTimeout(function() {
+      results.push(4);
+      cb();
+    }, 1000);
+  });
+  pend.wait(function(err) {
+    assert.deepEqual(results, [1,2,3,4]);
+    cb();
+  });
+  assert.deepEqual(results, [1, 2]);
+}
+
+function testWithMax(cb) {
+  var pend = new Pend();
+  var results = [];
+  pend.max = 2;
+  pend.go(function(cb) {
+    results.push('a');
+    setTimeout(function() {
+      results.push(1);
+      cb();
+    }, 500);
+  });
+  pend.go(function(cb) {
+    results.push('b');
+    setTimeout(function() {
+      results.push(1);
+      cb();
+    }, 500);
+  });
+  pend.go(function(cb) {
+    results.push('c');
+    setTimeout(function() {
+      results.push(2);
+      cb();
+    }, 100);
+  });
+  pend.wait(function(err) {
+    assert.deepEqual(results, ['a', 'b', 1, 'c', 1, 2]);
+    cb();
+  });
+  assert.deepEqual(results, ['a', 'b']);
+}
+
+function testCallbackTwice(cb) {
+  var pend = new Pend();
+  pend.go(function(cb) {
+    setTimeout(cb, 100);
+  });
+  pend.go(function(cb) {
+    cb();
+    assert.throws(cb, /callback called twice/);
+  });
+  pend.wait(cb);
+}
+
+function testCallingWaitTwice(cb) {
+  var pend = new Pend();
+  pend.go(function(cb) {
+    setTimeout(cb, 100);
+  });
+  pend.wait(function() {
+    pend.go(function(cb) {
+      setTimeout(cb, 50);
+    });
+    pend.go(function(cb) {
+      setTimeout(cb, 10);
+    });
+    pend.go(function(cb) {
+      setTimeout(cb, 20);
+    });
+    pend.wait(cb);
+  });
+}
+
+function testHoldFn(cb) {
+  var pend = new Pend();
+  setTimeout(pend.hold(), 100);
+  pend.go(function(cb) {
+    cb();
+  });
+  pend.wait(cb);
+}