universal-parcel-scraper 0.76.0-main.933 → 0.77.0-main.937

package/README.md

@@ -13,7 +13,7 @@ The engine behind [Peek](https://peektracker.com) ([GitHub](https://github.com/p
 [![License: Apache-2.0](https://img.shields.io/badge/core-Apache--2.0-blue.svg)](LICENSE)
 
 <!-- GENERATED:summary -->
-**3,500+ carriers** through **132 dedicated adapters** and **5 universal fallbacks**
+**3,500+ carriers** through **134 dedicated adapters** and **5 universal fallbacks**
 
 <sub>207 catalog entries · 66 countries represented</sub>
 <!-- /GENERATED:summary -->
@@ -155,7 +155,7 @@ createTracker({ providers: ['ParcelsApp', 'Ship24', '17TRACK', 'Postal Ninja', '
 <!-- GENERATED:stages -->
 <img src="docs/assets/stages.svg" alt="DHL: Die Sendung wurde in das Zustellfahrzeug geladen.; Mondial Relay: En cours de livraison; Correios Brazil: Objeto saiu para entrega ao destinatário; Correos Express: EN REPARTO; Yamato Transport: 配達中; La Poste / Colissimo: DISTOU. All are filed under out_for_delivery." width="760">
 
-The carrier folders record 3,704 such statuses, each filed under one stage.
+The carrier folders record 3,732 such statuses, each filed under one stage.
 <!-- /GENERATED:stages -->
 
 Wording nobody recorded yet goes through a classifier that reads seven European languages.

package/data/catalog.json

@@ -5480,7 +5480,9 @@
     "timezone": "Europe/Dublin",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "dpd-ie",
+      "recognitionRank": 62,
+      "localClocks": true
     },
     "canaryUrl": "https://www.dpd.ie/tracking/",
     "trackingUrlTemplate": "https://www.dpd.ie/tracking/?consignmentNumber={trackingNumber}",
@@ -8008,7 +8010,9 @@
     "timezone": "Europe/Vilnius",
     "tracking": {
       "mode": "automatic",
-      "adapter": "universal"
+      "adapter": "venipak",
+      "recognitionRank": 63,
+      "localClocks": true
     },
     "canaryUrl": "https://venipak.com/lt/en/parcel-tracking/",
     "trackingUrlTemplate": "https://venipak.com/lt/en/tracking/track/{trackingNumber}",

package/data/coverage-summary.json

@@ -1,6 +1,6 @@
 {
   "catalog": 207,
-  "activeAdapters": 132,
+  "activeAdapters": 134,
   "countries": 66,
   "referenceCarriers": 100,
   "comparison": {

package/dist/browser/scraper.js

@@ -4443,7 +4443,9 @@ var ye = {
 		timezone: "Europe/Dublin",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "dpd-ie",
+			recognitionRank: 62,
+			localClocks: !0
 		},
 		canaryUrl: "https://www.dpd.ie/tracking/",
 		trackingUrlTemplate: "https://www.dpd.ie/tracking/?consignmentNumber={trackingNumber}",
@@ -6320,7 +6322,9 @@ var ye = {
 		timezone: "Europe/Vilnius",
 		tracking: {
 			mode: "automatic",
-			adapter: "universal"
+			adapter: "venipak",
+			recognitionRank: 63,
+			localClocks: !0
 		},
 		canaryUrl: "https://venipak.com/lt/en/parcel-tracking/",
 		trackingUrlTemplate: "https://venipak.com/lt/en/tracking/track/{trackingNumber}",
@@ -11710,6 +11714,7 @@ var _c = {
 	"dhl-express": 75,
 	dpd: 70,
 	"dpd-de": 65,
+	"dpd-ie": 62,
 	"dpd-pl": 8,
 	econt: 56,
 	elta: 55,
@@ -11751,7 +11756,8 @@ var _c = {
 	tipsa: 24,
 	tnt: 44,
 	ukrposhta: 5,
-	uniuni: 33
+	uniuni: 33,
+	venipak: 63
 }, vc = 5;
 function yc(e) {
 	let t = y(e);

package/dist/carriers/dpd-de/service.d.ts

@@ -132,10 +132,10 @@ export declare function sharedDpdAppService(options?: Pick<AdapterEnvironment, '
  * background, and keeps one open for the life of the process, so that no lookup waits the tens of
  * seconds an opening takes. For a long-lived host, with the `fetcher` and `userAgent` it gives
  * `createTracker` or its adapter environment. With a `store`, a restart takes the saved session up
- * again, and the sessions no longer used are checked every hour until the service refuses them,
- * which the store records. `onSession` hears of each session taken up and each opening that ends,
- * so the host can tell how long openings take and when one fails. The timers do not keep the
- * process alive.
+ * again, and the sessions no longer used are checked every hour, also across restarts, until the
+ * service refuses them, which the store records. `onSession` hears of each session taken up and
+ * each opening that ends, so the host can tell how long openings take and when one fails. The
+ * timers do not keep the process alive.
  */
 export declare function warmDpdSession(environment?: Pick<AdapterEnvironment, 'fetcher' | 'userAgent'>, options?: {
     store?: DpdSessionStore;

package/dist/carriers/dpd-de/service.js

@@ -16,9 +16,9 @@ const MAX_BYTES = 2_000_000;
 /** Opening a session has taken up to 75 seconds. */
 const SESSION_OPEN_MS = 120_000;
 /**
- * The service has accepted a session for over eighteen hours, used once an hour after its first
- * eight, and one left idle for four. From eight hours old the next one opens beside it, and
- * replaces it once open.
+ * The service has accepted a session for nearly twenty-seven hours, used once an hour after its
+ * first eight, and one left idle for four, and refused another from twenty-seven hours old. From
+ * eight hours old the next one opens beside it, and replaces it once open.
  */
 const SESSION_RENEW_MS = 8 * 3_600_000;
 /** A kept session that failed to open is tried again after this long. */
@@ -26,8 +26,9 @@ const SESSION_RETRY_MS = 15 * 60_000;
 /** A host's store has this long to give back its sessions before the service opens one. */
 const STORE_LOAD_MS = 5_000;
 /**
- * With a store, a session lookups no longer use is checked this often, until the service refuses
- * it twice in a row: while slow, it can refuse a session it accepts again later.
+ * With a store, a session lookups no longer use is checked once it was last asked about this
+ * long ago, counting a check saved before a restart, until the service refuses it twice in a row:
+ * while slow, it can refuse a session it accepts again later.
  */
 const CHECK_EVERY_MS = 3_600_000;
 /** And for at most this long after it opened. */
@@ -224,7 +225,7 @@ export class DpdAppService {
         else if (newest)
             older.unshift(newest);
         for (const session of older)
-            this.#retired.set(session.token, { session: { ...session } });
+            this.#retired.set(session.token, { session: { ...session }, askedAt: session.checkedAt ?? session.openedAt });
     }
     /** Saves a session's state in the host's store, if there is one, without waiting for it. */
     #save(session) {
@@ -234,18 +235,22 @@ export class DpdAppService {
     }
     /** Follows a session lookups no longer use, when a store keeps what its checks find. */
     #retire(session, refusedAt) {
-        if (this.#store && !this.#retired.has(session.token))
-            this.#retired.set(session.token, { session: { ...session }, refusedSince: refusedAt });
+        if (this.#store && !this.#retired.has(session.token)) {
+            this.#retired.set(session.token, { session: { ...session }, askedAt: this.#now(), refusedSince: refusedAt });
+        }
     }
-    /** Checks the sessions lookups no longer use, every hour. */
+    /** Checks the sessions lookups no longer use when the first of them is due. */
     #follow() {
-        const timer = setTimeout(() => void this.#check().finally(() => this.#follow()), CHECK_EVERY_MS);
+        let due = this.#now() + CHECK_EVERY_MS;
+        for (const retired of this.#retired.values())
+            due = Math.min(due, retired.askedAt + CHECK_EVERY_MS);
+        const timer = setTimeout(() => void this.#check().finally(() => this.#follow()), Math.max(0, due - this.#now()));
         timer.unref?.();
     }
     /**
-     * Asks the service once for each followed session whether it still accepts it. A refusal
-     * confirmed by the next check is saved as the time it began; a reply that is not about the
-     * session says nothing.
+     * Asks the service once for each followed session that is due whether it still accepts it. A
+     * refusal confirmed by the next check is saved as the time it began; a reply that is not about
+     * the session says nothing.
      */
     async #check() {
         let first = true;
@@ -255,9 +260,12 @@ export class DpdAppService {
                 this.#retired.delete(token);
                 continue;
             }
+            if (now - retired.askedAt < CHECK_EVERY_MS)
+                continue;
             if (!first)
                 await new Promise((resolve) => { setTimeout(resolve, CHECK_GAP_MS).unref?.(); });
             first = false;
+            retired.askedAt = this.#now();
             let accepted;
             try {
                 await this.call('getParcelShopByID', { SessionToken: token, ParcelShopID: '0', PudoID: CHECK_PUDO_ID, ParcelShopOnly: 'false' }, AbortSignal.timeout(CHECK_TIMEOUT_MS), CHECK_TIMEOUT_MS);
@@ -439,10 +447,10 @@ export function sharedDpdAppService(options = {}) {
  * background, and keeps one open for the life of the process, so that no lookup waits the tens of
  * seconds an opening takes. For a long-lived host, with the `fetcher` and `userAgent` it gives
  * `createTracker` or its adapter environment. With a `store`, a restart takes the saved session up
- * again, and the sessions no longer used are checked every hour until the service refuses them,
- * which the store records. `onSession` hears of each session taken up and each opening that ends,
- * so the host can tell how long openings take and when one fails. The timers do not keep the
- * process alive.
+ * again, and the sessions no longer used are checked every hour, also across restarts, until the
+ * service refuses them, which the store records. `onSession` hears of each session taken up and
+ * each opening that ends, so the host can tell how long openings take and when one fails. The
+ * timers do not keep the process alive.
  */
 export function warmDpdSession(environment = {}, options = {}) {
     sharedDpdAppService(environment).keep(options);

package/dist/carriers/dpd-ie/adapter.d.ts

@@ -0,0 +1,14 @@
+import { type AdapterFactory, type TrackingContext } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+import { type StepRecorder } from '../../core/telemetry/index.js';
+export declare class DpdIeTracker {
+    private readonly options;
+    constructor(options?: {
+        fetcher?: typeof fetch;
+        recorder?: StepRecorder;
+        userAgent?: string;
+    });
+    fetch(raw: string, context?: TrackingContext): Promise<CarrierResult>;
+    private lookup;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/dpd-ie/adapter.js

@@ -0,0 +1,100 @@
+import { accepted, recognizeFromLookup } from '../../core/adapter/index.js';
+import { BudgetExceededError, ChallengeError, IndeterminateError, SchemaError } from '../../core/errors/index.js';
+import { runSteps } from '../../core/runner/index.js';
+import { firstAttemptMs, networkRetryStep } from '../../core/runner/networkRetry.js';
+import { NOOP_RECORDER } from '../../core/telemetry/index.js';
+import { decodeText, fetchBounded, userAgentOf } from '../../core/transport/index.js';
+import { isDpdIeChallenge, normalizeDpdIeNumber, parseDpdIe, parseDpdIeAbsence, PROVIDER } from './parser.js';
+// The tracker www.dpd.ie/tracking/ shows in a frame, with the frame's device type.
+const ORIGIN = 'https://tracking.dpd.ie';
+const RESULT = '/Home/SearchResult?deviceType=5';
+// Where the tracker sends a consignment it does not have.
+const ABSENT = '/Custom500.html?aspxerrorpath=/Home/SearchResult';
+// The result page is about 10 kB.
+const MAX_BYTES = 512 * 1024;
+const REDIRECTS = [301, 302, 303, 307, 308];
+const COOKIE = /^(ASP\.NET_SessionId|__cf_bm)=([A-Za-z0-9._~:=+/-]{1,512})(?:;|$)/;
+/** The anonymous session the search opens; the result page reads the consignment from it. */
+function sessionCookie(response) {
+    const cookies = new Map();
+    for (const header of response.headers.getSetCookie()) {
+        const match = COOKIE.exec(header);
+        if (match)
+            cookies.set(match[1], `${match[1]}=${match[2]}`);
+    }
+    return cookies.has('ASP.NET_SessionId') ? [...cookies.values()].join('; ') : null;
+}
+/** A redirect's target on the tracker's own host, as a path with its query, or null. */
+function redirectPath(response) {
+    const location = response.headers.get('location');
+    if (!location)
+        return null;
+    try {
+        const target = new URL(location, `${ORIGIN}/`);
+        return target.origin === ORIGIN ? target.pathname + target.search : null;
+    }
+    catch {
+        return null;
+    }
+}
+export class DpdIeTracker {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async fetch(raw, context = {}) {
+        const number = normalizeDpdIeNumber(raw);
+        const budgetMs = context.budgetMs ?? 15_000;
+        // A request that fails to reach DPD Ireland, or hangs, gets one more try
+        // with a new session: the first gets half of the budget.
+        return runSteps({ carrier: 'dpd-ie', budgetMs, signal: context.signal, recorder: this.options.recorder ?? NOOP_RECORDER }, [
+            { id: 'direct', run: ({ signal, remainingMs }) => this.lookup(number, signal, firstAttemptMs(remainingMs), budgetMs) },
+            networkRetryStep(({ signal, remainingMs }) => this.lookup(number, signal, remainingMs, budgetMs)),
+        ]);
+    }
+    async lookup(number, signal, timeoutMs, budgetMs) {
+        const deadline = performance.now() + timeoutMs;
+        const userAgent = userAgentOf(this.options.userAgent);
+        const read = async (path, cookie) => {
+            const left = deadline - performance.now();
+            if (left <= 0)
+                throw new BudgetExceededError(PROVIDER, budgetMs);
+            signal.throwIfAborted();
+            const { response, bytes } = await fetchBounded(`${ORIGIN}${path}`, { signal, headers: {
+                    'User-Agent': userAgent, Accept: 'text/html', ...(cookie ? { Cookie: cookie } : {}),
+                } }, { provider: PROVIDER, timeoutMs: Math.max(1, Math.floor(left)), maxBytes: MAX_BYTES, redirect: 'manual',
+                allowHttpStatuses: [...REDIRECTS, 404, 410], fetcher: this.options.fetcher });
+            signal.throwIfAborted();
+            // A missing page says nothing about the consignment.
+            if (response.status === 404 || response.status === 410)
+                throw new IndeterminateError(PROVIDER, 'DPD Ireland tracking is unavailable');
+            return { response, html: decodeText(bytes) };
+        };
+        // The search stores the number in a new session and sends the browser to the result page.
+        const search = await read(`/?${new URLSearchParams({ deviceType: '5', consignmentNumber: number })}`);
+        if (!REDIRECTS.includes(search.response.status)) {
+            if (isDpdIeChallenge(search.html))
+                throw new ChallengeError(PROVIDER, 'DPD Ireland asked for a browser check');
+            throw new SchemaError(PROVIDER, 'DPD Ireland did not accept the consignment number');
+        }
+        const cookie = sessionCookie(search.response);
+        if (redirectPath(search.response) !== RESULT || !cookie) {
+            throw new IndeterminateError(PROVIDER, 'DPD Ireland did not open a tracking session');
+        }
+        const result = await read(RESULT, cookie);
+        if (REDIRECTS.includes(result.response.status)) {
+            if (redirectPath(result.response) !== ABSENT)
+                throw new IndeterminateError(PROVIDER, 'DPD Ireland did not keep the tracking session');
+            return parseDpdIeAbsence((await read(ABSENT)).html);
+        }
+        return parseDpdIe(result.html, number);
+    }
+}
+export const adapter = environment => {
+    const tracker = new DpdIeTracker({ fetcher: environment.fetcher, recorder: environment.recorder, userAgent: environment.userAgent });
+    return {
+        id: 'dpd-ie', recordsSteps: true, steps: ['direct', 'retry'],
+        track: (input, context) => tracker.fetch(input.number, context),
+        recognize: (number, context) => recognizeFromLookup(() => tracker.fetch(number, context), () => accepted(() => normalizeDpdIeNumber(number))),
+    };
+};

package/dist/carriers/dpd-ie/carrier.json

@@ -16,18 +16,50 @@
   "timezone": "Europe/Dublin",
   "tracking": {
     "mode": "automatic",
-    "adapter": "universal",
-    "steps": []
+    "adapter": "dpd-ie",
+    "steps": [
+      "direct",
+      "retry"
+    ],
+    "recognition": {
+      "rank": 62
+    },
+    "localClocks": true
   },
-  "capabilities": [],
+  "capabilities": [
+    "history",
+    "location",
+    "eta",
+    "delivered_at"
+  ],
   "portal": {
     "url": "https://www.dpd.ie/tracking/?consignmentNumber={trackingNumber}",
     "searchUrl": "https://www.dpd.ie/tracking/",
     "canaryUrl": "https://www.dpd.ie/tracking/",
-    "shows": [],
-    "scraped": [],
-    "discarded": [],
-    "unavailable": []
+    "shows": [
+      "status",
+      "history",
+      "location",
+      "eta",
+      "eta_window",
+      "parcel_count"
+    ],
+    "scraped": [
+      "status",
+      "history",
+      "location",
+      "eta",
+      "eta_window",
+      "delivered_at"
+    ],
+    "discarded": [
+      "parcel_count"
+    ],
+    "unavailable": [
+      "weight",
+      "sender_name",
+      "offset_timestamps"
+    ]
   },
   "links": [
     {

package/dist/carriers/dpd-ie/numbers.json

@@ -244,13 +244,13 @@
         "access": "indexed_excerpt"
       },
       "context": {
-        "assessment": "candidate"
+        "assessment": "confirmed"
       },
       "expect": {
         "carrier": "unknown",
         "confidence": "none"
       },
-      "note": "Looked up on DPD Ireland's own tracker, as an archived address shows; the capture was not opened."
+      "note": "Looked up on DPD Ireland's own tracker, as an archived address shows. DPD Ireland's tracker returns its history."
     }
   ]
 }

package/dist/carriers/dpd-ie/parser.d.ts

@@ -0,0 +1,19 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare const PROVIDER = "DPD Ireland";
+export declare const DPD_IE_ZONE = "Europe/Dublin";
+/** A DPD Ireland consignment number: nine or ten digits. */
+export declare function normalizeDpdIeNumber(raw: string): string;
+/** Cloudflare's challenge page in place of the tracker. Its passive script on ordinary pages is not one. */
+export declare function isDpdIeChallenge(html: string): boolean;
+/**
+ * The page the tracker sends an unknown consignment to. A redirect to it is
+ * the tracker's only answer for a number it does not have, so its notice must
+ * be the not-found one.
+ */
+export declare function parseDpdIeAbsence(html: string): never;
+/**
+ * The tracker's result for one consignment: its scans, oldest first, and a
+ * headline with the current status. A consignment of several parcels repeats
+ * each scan once per parcel.
+ */
+export declare function parseDpdIe(html: string, raw: string): CarrierResult;

package/dist/carriers/dpd-ie/parser.js

@@ -0,0 +1,198 @@
+import { load } from 'cheerio';
+import { DateTime } from 'luxon';
+import { normalizeTrackingNumber } from '../../core/detection/index.js';
+import { ChallengeError, IndeterminateError, InvalidInputError, NoHistoryError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { languageStageStatus } from '../../core/status/index.js';
+import { normalizeStatusWording } from '../../core/status/statusMap.js';
+import { clean } from '../../core/transport/index.js';
+import { DPD_IE_DRIVER_COLLECTION, DPD_IE_POINT_COLLECTION, DPD_IE_POINT_DROP_OFF, dpdIeScanStage, isDpdIeNotice } from './status.js';
+export const PROVIDER = 'DPD Ireland';
+export const DPD_IE_ZONE = 'Europe/Dublin';
+// The consignment numbers DPD Ireland's tracker shows have nine digits;
+// lookups archived from it also use ten.
+const NUMBER = /^\d{9,10}$/;
+const HEADERS = ['Status', 'Location', 'Date & Time'];
+// "07/9/2026 at 1:41": day, month without its zero, year, then the hour without its zero.
+const CLOCK = /^(\d{1,2})\/(\d{1,2})\/(\d{4}) at (\d{1,2}):(\d{2})$/;
+// DPD Ireland's own depots, in the Republic and in Northern Ireland, and its
+// head office and website. Their clocks are Irish wall time. Another
+// network's scan names its town and country, as "<town> - <country>".
+const IRISH_PLACE = /^(?:Dpd [A-Za-z][A-Za-z .'-]{0,60}|Head Office|Web)$/i;
+// Labels of DPD Ireland's systems rather than places.
+const NOT_PLACES = new Set(['head office', 'web']);
+const VAN = 'Your parcel is on a van and due for delivery';
+// The scan's text ends with the delivery window, cut to the field's length.
+const VAN_WINDOW = new RegExp(`^(${VAN}), between\\b.*$`);
+// The headline of a parcel on the van, with the whole window.
+const VAN_HEADLINE = new RegExp(`^${VAN}\\. Expected delivery time (\\d{2}):(\\d{2}) - (\\d{2}):(\\d{2})$`);
+const MAX_ROWS = 500;
+const same = (left, right) => normalizeStatusWording(left) === normalizeStatusWording(right);
+const MAX_EVENTS = 100;
+/** A DPD Ireland consignment number: nine or ten digits. */
+export function normalizeDpdIeNumber(raw) {
+    const number = normalizeTrackingNumber(raw);
+    if (!NUMBER.test(number))
+        throw new InvalidInputError(PROVIDER, 'DPD Ireland tracks nine- or ten-digit consignment numbers');
+    return number;
+}
+/** Cloudflare's challenge page in place of the tracker. Its passive script on ordinary pages is not one. */
+export function isDpdIeChallenge(html) {
+    return /<title>\s*Just a moment|_cf_chl_opt|cf-turnstile/i.test(html);
+}
+/**
+ * The page the tracker sends an unknown consignment to. A redirect to it is
+ * the tracker's only answer for a number it does not have, so its notice must
+ * be the not-found one.
+ */
+export function parseDpdIeAbsence(html) {
+    const $ = load(html);
+    $('script, style, noscript').remove();
+    const notice = clean($('body').text(), 400);
+    if (/^We couldn't locate the consignment number\.\s*It may not have reached our sorting hub yet, or it might be older than six months\.$/
+        .test(notice.replace(/[’‘]/g, "'"))) {
+        throw new NotFoundError(PROVIDER);
+    }
+    if (isDpdIeChallenge(html))
+        throw new ChallengeError(PROVIDER, 'DPD Ireland asked for a browser check');
+    throw new IndeterminateError(PROVIDER, 'DPD Ireland returned an error page without its not-found notice');
+}
+function clockOf(text) {
+    const match = CLOCK.exec(text);
+    if (!match)
+        return null;
+    const [, day, month, year, hour, minute] = match;
+    // UTC only checks the calendar fields. The zone is assigned per row.
+    const parsed = DateTime.fromObject({ year: Number(year), month: Number(month), day: Number(day), hour: Number(hour),
+        minute: Number(minute) }, { zone: 'UTC' });
+    if (!parsed.isValid)
+        return null;
+    return { day: parsed.toFormat('yyyy-MM-dd'), time: parsed.toFormat('HH:mm:ss'), text };
+}
+function irishTime(day, time) {
+    const parsed = DateTime.fromISO(`${day}T${time}`, { zone: DPD_IE_ZONE });
+    return parsed.isValid ? parsed.toISO({ suppressMilliseconds: true }) : null;
+}
+/** The delivery window the headline gives a parcel on the van, on the day of its van scan. */
+function vanWindow(headline, van) {
+    const match = VAN_HEADLINE.exec(headline);
+    if (!match || !van.time)
+        return null;
+    const day = DateTime.fromISO(van.time, { setZone: true }).toFormat('yyyy-MM-dd');
+    const from = irishTime(day, `${match[1]}:${match[2]}:00`);
+    const to = irishTime(day, `${match[3]}:${match[4]}:00`);
+    if (!from || !to || Date.parse(from) >= Date.parse(to) || Date.parse(to) < Date.parse(van.time))
+        return null;
+    return { expected_delivery_from: from, expected_delivery: to };
+}
+/**
+ * The tracker's result for one consignment: its scans, oldest first, and a
+ * headline with the current status. A consignment of several parcels repeats
+ * each scan once per parcel.
+ */
+export function parseDpdIe(html, raw) {
+    const number = normalizeDpdIeNumber(raw);
+    const $ = load(html);
+    const root = $('div.status-container');
+    if (root.length !== 1) {
+        if (isDpdIeChallenge(html))
+            throw new ChallengeError(PROVIDER, 'DPD Ireland asked for a browser check');
+        throw new IndeterminateError(PROVIDER, 'DPD Ireland did not return a consignment');
+    }
+    const info = root.find('.tracking-status-info p').filter((_, node) => /^Consignment\b/.test(clean($(node).text(), 80)));
+    if (info.length !== 1 || info.find('strong').length !== 1 || clean(info.find('strong').text(), 40) !== number) {
+        throw new SchemaError(PROVIDER, 'DPD Ireland returned a different consignment');
+    }
+    const lists = root.find('ul.history-list');
+    if (lists.length !== 1)
+        throw new SchemaError(PROVIDER, 'DPD Ireland tracking history changed');
+    // Wording is mapped in English, the tracker's only language.
+    const headers = lists.find('li.header-list h4').map((_, node) => clean($(node).text(), 40)).get();
+    if (headers.join('|') !== HEADERS.join('|'))
+        throw new SchemaError(PROVIDER, 'DPD Ireland history columns changed');
+    const rows = lists.children('li').not('.header-list');
+    if (!rows.length)
+        throw new NoHistoryError(PROVIDER);
+    if (rows.length > MAX_ROWS)
+        throw new SchemaError(PROVIDER, 'DPD Ireland returned too many scans');
+    const scans = [];
+    const seen = new Set();
+    for (const row of rows.toArray()) {
+        const node = $(row);
+        const cells = node.children('div');
+        if (cells.length !== 3)
+            throw new SchemaError(PROVIDER, 'DPD Ireland history columns changed');
+        const shown = clean(cells.eq(0).find('strong').first().text(), 200);
+        const wording = shown.replace(VAN_WINDOW, '$1');
+        const place = clean(cells.eq(1).text(), 120);
+        const clock = clockOf(clean(cells.eq(2).text(), 40));
+        if (!wording)
+            throw new SchemaError(PROVIDER, 'DPD Ireland returned a scan without wording');
+        if (!clock)
+            throw new SchemaError(PROVIDER, 'DPD Ireland returned an invalid scan time');
+        // Irish depots and systems keep Irish time. Another network's scan names
+        // its own country, and no offset is established for it.
+        const time = IRISH_PLACE.test(place) ? irishTime(clock.day, clock.time) : null;
+        const event = {
+            ...(time ? { time } : { local_time: `${clock.day}T${clock.time}`, provider_time_text: clock.text }),
+            description: wording,
+            ...(place && !NOT_PLACES.has(place.toLowerCase()) ? { location: place } : {}),
+        };
+        // Each parcel of a consignment repeats the scan.
+        const identity = JSON.stringify(event);
+        if (seen.has(identity))
+            continue;
+        seen.add(identity);
+        scans.push({ wording, event });
+    }
+    // Oldest first: a collection's stage depends on the scans before it, and a
+    // notice keeps the stage of the scan before it.
+    let previous;
+    let droppedAtPoint = false;
+    for (const { wording, event } of scans) {
+        let stage;
+        if (same(wording, DPD_IE_DRIVER_COLLECTION))
+            stage = previous && previous !== 'registered' ? 'in_transit' : 'accepted';
+        else if (same(wording, DPD_IE_POINT_COLLECTION)) {
+            if (!droppedAtPoint) {
+                // Possibly the recipient's collection: no stage of its own.
+                Object.assign(event, { stage: previous ?? 'registered', stage_source: 'none' });
+                continue;
+            }
+            stage = 'in_transit';
+        }
+        else if (isDpdIeNotice(wording)) {
+            Object.assign(event, { stage: previous ?? 'registered', stage_source: 'none' });
+            continue;
+        }
+        else
+            stage = dpdIeScanStage(wording);
+        if (same(wording, DPD_IE_POINT_DROP_OFF))
+            droppedAtPoint = true;
+        else if (stage && stage !== 'registered' && stage !== 'accepted')
+            droppedAtPoint = false;
+        if (!stage)
+            continue;
+        Object.assign(event, { stage, stage_source: 'carrier_map' });
+        previous = stage;
+    }
+    const ordered = [...scans].reverse();
+    const events = ordered.map(scan => scan.event);
+    const decider = ordered.find(scan => scan.event.stage_source !== 'none')?.event;
+    if (!decider)
+        throw new IndeterminateError(PROVIDER, 'DPD Ireland returned no parcel scans');
+    const stage = decider.stage;
+    const latest = events[0];
+    const headline = clean(root.find('.delivery-box h3').first().text(), 200);
+    const window = stage === 'out_for_delivery' && same(decider.description ?? '', VAN) ? vanWindow(headline, decider) : null;
+    return {
+        status: stage ? languageStageStatus(stage) : 'unknown',
+        ...(stage ? { current_stage: stage, current_stage_source: 'carrier_map' } : {}),
+        last_status_text: decider.description ?? null,
+        last_update: latest.time ?? null,
+        ...(latest.time ? {} : { last_update_local: latest.local_time }),
+        expected_delivery: window?.expected_delivery ?? null,
+        ...(window ? { expected_delivery_from: window.expected_delivery_from } : {}),
+        ...(stage === 'delivered' && decider.time ? { delivered_at: decider.time } : {}),
+        events: events.slice(0, MAX_EVENTS),
+    };
+}

package/dist/carriers/dpd-ie/status.d.ts

@@ -0,0 +1,27 @@
+import type { Stage } from '../../core/status/index.js';
+import { type CarrierStatusMap } from '../../core/status/statusMap.js';
+/**
+ * The tracking page's scan wording, mapped whole. The page gives no status
+ * code. The shared classifier leaves most of these without a stage, and it
+ * would read a pickup point's hand-over to DPD as a delivery.
+ */
+export declare const DPD_IE_SCANS: Readonly<Record<string, Stage>>;
+/** A DPD driver's collection: it accepts the parcel, unless an earlier scan already did or moved it. */
+export declare const DPD_IE_DRIVER_COLLECTION = "Parcel collected by DPD Driver";
+/**
+ * A Pickup shop handing a parcel over. After the sender dropped it at the
+ * shop, DPD takes it on; any other time it may be the recipient's
+ * collection, which the wording alone does not tell.
+ */
+export declare const DPD_IE_POINT_COLLECTION = "Your parcel has been collected from the Pickup Point";
+/** The sender's drop-off at a Pickup shop, after which the shop's hand-over is DPD's collection. */
+export declare const DPD_IE_POINT_DROP_OFF = "Customer dropped parcel at Pick Up Point";
+/** The stage the wording alone gives a scan, if any. */
+export declare function dpdIeScanStage(wording: string): Stage | undefined;
+export declare function isDpdIeNotice(wording: string): boolean;
+/**
+ * What the map says about one scan. The two collections take their stage
+ * from the scans before them, so the map does not know it from their
+ * wording; notices are left without a stage on purpose.
+ */
+export declare const statusMap: CarrierStatusMap;