universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/ontrac/numbers.json

@@ -0,0 +1,214 @@
+{
+  "carrier": "ontrac",
+  "records": [
+    {
+      "number": "1LS7119013618127-1",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "1LS717793482164",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "1LS724505321754",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "1LSCXLNA062725426",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://www.trustpilot.com/reviews/6ab588e6e22febb9c383f965",
+        "date": "2026-09-24"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified."
+    },
+    {
+      "number": "1LSCXVE0058631Y",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "1LSCXVE005BUEFX",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "C11031500001879",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/ontrac.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "C11121552953069",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/ontrac.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "D10011345983010",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/ontrac.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "D10011354453707",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/ontrac.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LA28376237",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LE10917377",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LH13830790",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LI12976442",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LN30083672",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "LX17635036",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/lasership.json"
+      },
+      "expect": {
+        "carrier": "ontrac",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    }
+  ]
+}

package/dist/carriers/ontrac/parser.d.ts

@@ -0,0 +1,3 @@
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizeOntracNumber(raw: string): string;
+export declare function parseOntrac(payload: unknown, number: string): CarrierResult;

package/dist/carriers/ontrac/parser.js

@@ -0,0 +1,72 @@
+import { DateTime } from 'luxon';
+import { IndeterminateError, SchemaError } from '../../core/errors/index.js';
+import { explicitOffsetTime } from '../../core/time/index.js';
+import { clean } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { classifyOntracStatus } from './status.js';
+export function normalizeOntracNumber(raw) {
+    const number = raw.toUpperCase().replace(/[\s.-]/g, '');
+    if (!/^(?:[CD]\d{14}|L[AIEHNX]\d{8}|1LS[A-Z0-9]{12,14})$/.test(number)) {
+        throw new TypeError('OnTrac requires an OnTrac or LaserShip tracking number');
+    }
+    return number;
+}
+function unresolvedWallTime(value) {
+    const raw = clean(value, 64);
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/.test(raw))
+        return null;
+    // UTC validates the digits only; no timezone is assigned to this wall clock.
+    const parsed = DateTime.fromISO(raw, { zone: 'UTC' });
+    return parsed.isValid ? parsed.toISO({ includeOffset: false, suppressMilliseconds: true }) : null;
+}
+export function parseOntrac(payload, number) {
+    const requested = normalizeOntracNumber(number);
+    if (!isRecord(payload) || !Array.isArray(payload.Packages) || payload.Packages.length > 100) {
+        throw new SchemaError('OnTrac');
+    }
+    const matches = payload.Packages.filter(isRecord).filter((item) => clean(item.Tracking, 64).toUpperCase() === requested);
+    if (matches.length !== 1)
+        throw new SchemaError('OnTrac', 'OnTrac did not return one matching shipment');
+    const item = matches[0];
+    if (!Array.isArray(item.Events) || item.Events.length > 500)
+        throw new SchemaError('OnTrac');
+    const events = [];
+    const seen = new Set();
+    item.Events.forEach((raw) => {
+        if (!isRecord(raw))
+            throw new SchemaError('OnTrac', 'OnTrac returned an incomplete scan row');
+        const code = clean(raw.EventCode, 32);
+        const description = clean(raw.EventShortDescription, 500);
+        if (!description)
+            throw new SchemaError('OnTrac', 'OnTrac returned a scan with no description');
+        const time = explicitOffsetTime(raw.ZonedEventDateTime) ?? explicitOffsetTime(raw.UtcEventDateTime);
+        const local = time ? null : unresolvedWallTime(raw.ZonedEventDateTime) ?? unresolvedWallTime(raw.UtcEventDateTime);
+        const location = [clean(raw.City, 100), clean(raw.State, 80)].filter(Boolean).join(', ');
+        const clockText = clean(raw.ZonedEventDateTime, 64) || clean(raw.UtcEventDateTime, 64);
+        const clock = time?.iso ?? local ?? clockText;
+        const key = `${clock}\u0000${code}\u0000${description}\u0000${location}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        const mapped = classifyOntracStatus(code);
+        events.push({ description, ...(time ? { time: time.iso } : {}), ...(local ? { local_time: local } : {}),
+            ...(!time && !local && clockText ? { provider_time_text: clockText } : {}),
+            ...(location ? { location } : {}), ...(code ? { provider_code: code } : {}), ...(mapped ? { stage: mapped.stage } : {}) });
+    });
+    if (!events.length)
+        throw new IndeterminateError('OnTrac', 'OnTrac returned no tracking scans');
+    // The endpoint sends newest first, including scans whose clocks lack offsets.
+    const latest = events[0];
+    const mapped = classifyOntracStatus(latest.provider_code ?? '');
+    const estimate = explicitOffsetTime(item.UtcExpectedDeliveryDateTime);
+    const weight = typeof item.Weight === 'number' && Number.isFinite(item.Weight) && item.Weight > 0 ? item.Weight : null;
+    const units = clean(item.WeightUnits, 16).toLowerCase();
+    const weightKg = weight !== null ? (units === 'lbs' || units === 'lb' ? weight * 0.45359237 : units === 'kg' ? weight : null) : null;
+    return {
+        status: mapped?.status ?? 'unknown', ...(mapped ? { current_stage: mapped.stage } : {}),
+        last_status_text: latest.description, last_update: latest.time ?? null, last_update_local: latest.local_time ?? null,
+        expected_delivery: mapped?.status === 'delivered' ? null : estimate?.iso ?? null,
+        ...(mapped?.status === 'delivered' && latest.time ? { delivered_at: latest.time } : {}),
+        ...(weightKg !== null ? { weight_kg: weightKg } : {}), events: events.slice(0, 100),
+    };
+}

package/dist/carriers/ontrac/status.d.ts

@@ -0,0 +1,2 @@
+import type { ClassifiedStatus } from '../../core/status/index.js';
+export declare function classifyOntracStatus(code: string): ClassifiedStatus | undefined;

package/dist/carriers/ontrac/status.js

@@ -0,0 +1,19 @@
+// The official portal's statusCodes.json describes both regional code sets.
+// Its presentation TYPE can label pickup as Created and damage or handoff as Delivered.
+// Classification follows the milestone description instead.
+const stages = {};
+function add(codes, status, stage) {
+    for (const code of codes)
+        stages[code] = { status, stage };
+}
+add(['XX', 'OVRC', 'AUTO', 'EXRL', 'INRL'], 'pending', 'registered');
+add(['PKUP', 'PU', 'RL', 'ALPK'], 'in_transit', 'accepted');
+add(['ARRD', 'ORIG', 'RCVD', 'OS', 'FCTF', 'SFCT', 'LOAD', 'NFRP'], 'in_transit', 'in_transit');
+add(['OFDL', 'OD'], 'out_for_delivery', 'out_for_delivery');
+add(['BCLD', 'UTLV', 'NH', 'ACSS', 'RFDM'], 'exception', 'failed_attempt');
+add(['DN', 'DLVD', 'CL', 'DM', 'DW', 'OK', 'DD'], 'delivered', 'delivered');
+add(['RETD', 'RETN', 'RS'], 'exception', 'returned');
+add(['LOST', 'MSPK', 'UD'], 'exception', 'exception');
+export function classifyOntracStatus(code) {
+    return stages[code];
+}

package/dist/carriers/ontrac/statuses.json

@@ -0,0 +1,61 @@
+{
+  "carrier": "ontrac",
+  "entries": [
+    {
+      "wording": "Package Delivered",
+      "language": "en",
+      "stage": "delivered",
+      "confirmedBy": "live",
+      "code": "DLVD"
+    },
+    {
+      "wording": "Out for Delivery",
+      "language": "en",
+      "stage": "out_for_delivery",
+      "confirmedBy": "live",
+      "code": "OFDL"
+    },
+    {
+      "wording": "Loaded onto vehicle",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "code": "LOAD"
+    },
+    {
+      "wording": "Business closed. Please provide hours",
+      "language": "en",
+      "stage": "failed_attempt",
+      "confirmedBy": "live",
+      "code": "BCLD"
+    },
+    {
+      "wording": "Delivery Pending",
+      "language": "en",
+      "stage": "failed_attempt",
+      "confirmedBy": "live",
+      "code": "UTLV"
+    },
+    {
+      "wording": "Arrived at Final Servicing Facility",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "code": "SFCT"
+    },
+    {
+      "wording": "Origin Scan",
+      "language": "en",
+      "stage": "in_transit",
+      "confirmedBy": "live",
+      "code": "ORIG"
+    },
+    {
+      "wording": "On its way to OnTrac",
+      "language": "en",
+      "stage": "registered",
+      "confirmedBy": "live",
+      "code": "EXRL"
+    }
+  ]
+}

package/dist/carriers/paack/adapter.d.ts

@@ -0,0 +1,19 @@
+import type { AdapterFactory } from '../../core/adapter/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+export declare function normalizePaackTrackingNumber(raw: string): string;
+export declare function normalizePaackPostcode(raw: string): string;
+export declare function paackTrackingUrl(rawTrackingNumber: string, rawPostcode: string): string;
+export declare function parsePaackTrackingResponse(payload: unknown, rawTrackingNumber: string): CarrierResult;
+export declare function parsePaackTrackingHtml(html: string, rawTrackingNumber: string): CarrierResult;
+export interface PaackTrackerOptions {
+    timeoutMs?: number;
+    /** Test seam; production uses the global fetch. */
+    fetcher?: typeof fetch;
+}
+export declare class PaackTracker {
+    readonly timeoutMs: number;
+    readonly fetcher?: typeof fetch;
+    constructor(options?: PaackTrackerOptions);
+    fetch(rawTrackingNumber: string, rawPostcode: string): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/paack/adapter.js

@@ -0,0 +1,255 @@
+/**
+ * Paack recipient tracking.
+ *
+ * The public page is a Remix application: one bounded GET with the order
+ * number and the delivery postcode returns server-rendered HTML whose
+ * `window.__remixContext` already holds the loader response for the tracking
+ * route. Reading that embedded payload avoids a second, undocumented API call
+ * and gives the same data the page itself renders. The order number the
+ * response echoes is verified before anything else is read.
+ *
+ * A wrong number or postcode is answered with a redirect back to the form, or
+ * with an explicit "order not found" message; both become a clean not-found.
+ *
+ * Privacy: the loader payload carries the retailer, the recipient's name,
+ * e-mail, phone and address, and per-event `variables` that repeat them.
+ * `parse()` copies nothing from those objects: each event is rebuilt from its
+ * timestamp, our own description and the mapped stage, and the only order-level
+ * fields read are the echoed identifier and the delivery window.
+ */
+import { load } from 'cheerio';
+import { IndeterminateError, InputRequiredError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { decodeText, fetchBounded, UpstreamHttpError } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { classifyPaackEvent } from './status.js';
+const TRACKING_ENDPOINT = 'https://mydeliveries.paack.app/tracking/order';
+const DEFAULT_TIMEOUT_MS = 15_000;
+const MAX_RESPONSE_BYTES = 2_000_000;
+const MAX_EVENTS = 100;
+const NOT_FOUND_PATTERN = /order not found|incorrect order number|commande introuvable|pedido no encontrado/i;
+const NOT_FOUND_PAGE_PATTERN = /order not found|incorrect order number or postal code|commande introuvable|pedido no encontrado/i;
+/**
+ * Kept local rather than taken from core/time: the loader mixes epoch seconds,
+ * epoch milliseconds and offset-bearing ISO strings in the same field, and the
+ * result keeps millisecond precision (`toISOString()`), which the core helpers
+ * deliberately suppress.
+ */
+function normalizedTimestamp(value) {
+    let timestamp;
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        timestamp = value < 10_000_000_000 ? value * 1_000 : value;
+    }
+    else if (typeof value === 'string' && value.trim()) {
+        timestamp = Date.parse(value.trim());
+    }
+    else {
+        return null;
+    }
+    if (!Number.isFinite(timestamp))
+        return null;
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime()))
+        return null;
+    return { iso: date.toISOString(), timestamp: date.getTime() };
+}
+function normalizedDate(value) {
+    if (typeof value === 'string') {
+        const candidate = value.trim();
+        const match = /^(\d{4}-\d{2}-\d{2})/.exec(candidate);
+        if (match && !Number.isNaN(Date.parse(candidate)))
+            return match[1];
+    }
+    return normalizedTimestamp(value)?.iso.slice(0, 10) ?? null;
+}
+function routeData(payload) {
+    if (!isRecord(payload))
+        throw new SchemaError('Paack', 'Paack returned an invalid tracking response');
+    if (isRecord(payload.orderTrackData))
+        return payload;
+    const state = payload.state;
+    if (!isRecord(state) || !isRecord(state.loaderData)) {
+        throw new SchemaError('Paack', 'Paack returned incomplete tracking details');
+    }
+    const route = state.loaderData['routes/tracking.order'];
+    if (!isRecord(route))
+        throw new SchemaError('Paack', 'Paack returned incomplete tracking details');
+    return route;
+}
+function errorText(payload) {
+    if (!isRecord(payload))
+        return '';
+    return [payload.error, payload.message, payload.statusText]
+        .filter((value) => typeof value === 'string')
+        .join(' ');
+}
+function remixContext(html) {
+    const $ = load(html);
+    let serialized = '';
+    $('script').each((_, element) => {
+        if (serialized)
+            return;
+        const script = $(element).html() ?? '';
+        const marker = 'window.__remixContext';
+        const markerIndex = script.indexOf(marker);
+        if (markerIndex < 0)
+            return;
+        const equalsIndex = script.indexOf('=', markerIndex + marker.length);
+        if (equalsIndex < 0)
+            return;
+        serialized = script.slice(equalsIndex + 1).trim().replace(/;\s*$/, '');
+    });
+    if (!serialized)
+        throw new SchemaError('Paack', 'Paack did not return tracking details');
+    try {
+        return JSON.parse(serialized);
+    }
+    catch (error) {
+        throw new SchemaError('Paack', 'Paack returned an invalid tracking response', { cause: error });
+    }
+}
+export function normalizePaackTrackingNumber(raw) {
+    const value = raw.trim().toLocaleUpperCase('en-US').replace(/\s/g, '');
+    if (!/^(?=.*\d)[A-Z0-9]{4,40}$/.test(value)) {
+        throw new TypeError('Paack tracking numbers must contain 4 to 40 ASCII letters and digits, including at least one digit');
+    }
+    return value;
+}
+export function normalizePaackPostcode(raw) {
+    const value = raw.trim().toLocaleUpperCase('en-US');
+    if (!/^(?=.{3,10}$)(?=.*\d)[A-Z0-9]+(?:[ -][A-Z0-9]+)*$/.test(value)) {
+        throw new TypeError('Paack tracking requires a 3- to 10-character alphanumeric delivery postcode');
+    }
+    return value.replace(/\s+/g, '');
+}
+export function paackTrackingUrl(rawTrackingNumber, rawPostcode) {
+    const trackingNumber = normalizePaackTrackingNumber(rawTrackingNumber);
+    const postcode = normalizePaackPostcode(rawPostcode);
+    const url = new URL(TRACKING_ENDPOINT);
+    url.searchParams.set('tracking_number', trackingNumber);
+    url.searchParams.set('postal_code', postcode);
+    return url.toString();
+}
+export function parsePaackTrackingResponse(payload, rawTrackingNumber) {
+    const trackingNumber = normalizePaackTrackingNumber(rawTrackingNumber);
+    if (NOT_FOUND_PATTERN.test(errorText(payload)))
+        throw new NotFoundError('Paack');
+    const route = routeData(payload);
+    if (NOT_FOUND_PATTERN.test(errorText(route)))
+        throw new NotFoundError('Paack');
+    const order = route.orderTrackData;
+    if (!isRecord(order))
+        throw new SchemaError('Paack', 'Paack returned incomplete tracking details');
+    const responseNumber = typeof order.external_id === 'string'
+        ? normalizePaackTrackingNumber(order.external_id)
+        : '';
+    if (!responseNumber)
+        throw new SchemaError('Paack', 'Paack returned an invalid shipment number');
+    if (responseNumber !== trackingNumber) {
+        throw new SchemaError('Paack', 'Paack returned a different shipment');
+    }
+    const rawEvents = Array.isArray(route.eventList) ? route.eventList : [];
+    const parsedEvents = [];
+    rawEvents.slice(0, 500).forEach((rawEvent, sourceIndex) => {
+        if (!isRecord(rawEvent) || rawEvent.timeline === false)
+            return;
+        const classified = classifyPaackEvent(rawEvent);
+        const time = normalizedTimestamp(rawEvent.timestamp ?? rawEvent.time);
+        if (!time)
+            return;
+        parsedEvents.push({
+            event: {
+                time: time.iso,
+                description: classified.description,
+                stage: classified.stage,
+            },
+            status: classified.status,
+            timestamp: time.timestamp,
+            sourceIndex,
+        });
+    });
+    parsedEvents.sort((left, right) => (right.timestamp - left.timestamp || left.sourceIndex - right.sourceIndex));
+    const events = parsedEvents.slice(0, MAX_EVENTS).map(({ event }) => event);
+    const activeEvent = isRecord(route.activeEvent) ? route.activeEvent : null;
+    const active = activeEvent ? classifyPaackEvent(activeEvent) : null;
+    const latest = parsedEvents.find((event) => event.status !== 'unknown');
+    const current = active && active.status !== 'unknown'
+        ? active
+        : latest && {
+            status: latest.status,
+            stage: latest.event.stage ?? 'in_transit',
+            description: latest.event.description ?? 'Shipment update',
+        };
+    if (!current)
+        throw new SchemaError('Paack', 'Paack returned incomplete tracking details');
+    const activeTime = activeEvent
+        ? normalizedTimestamp(activeEvent.timestamp ?? activeEvent.time)
+        : null;
+    const expected = isRecord(order.expected_delivery_ts)
+        ? normalizedDate(order.expected_delivery_ts.end ?? order.expected_delivery_ts.start)
+        : null;
+    return {
+        status: current.status,
+        current_stage: current.stage,
+        last_status_text: current.description,
+        last_update: activeTime?.iso ?? events[0]?.time ?? null,
+        expected_delivery: ['delivered', 'exception'].includes(current.status) ? null : expected,
+        timezone: 'Europe/Paris',
+        events,
+    };
+}
+export function parsePaackTrackingHtml(html, rawTrackingNumber) {
+    // An empty body proves nothing about the shipment, so it stays indeterminate.
+    if (!html.trim())
+        throw new IndeterminateError('Paack', 'Paack returned an empty tracking response');
+    if (NOT_FOUND_PAGE_PATTERN.test(html))
+        throw new NotFoundError('Paack');
+    return parsePaackTrackingResponse(remixContext(html), rawTrackingNumber);
+}
+export class PaackTracker {
+    timeoutMs;
+    fetcher;
+    constructor(options = {}) {
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.fetcher = options.fetcher;
+        if (!Number.isFinite(this.timeoutMs) || this.timeoutMs <= 0) {
+            throw new TypeError('Paack timeout must be positive');
+        }
+    }
+    async fetch(rawTrackingNumber, rawPostcode) {
+        const trackingNumber = normalizePaackTrackingNumber(rawTrackingNumber);
+        const postcode = normalizePaackPostcode(rawPostcode);
+        const { response, bytes } = await fetchBounded(paackTrackingUrl(trackingNumber, postcode), {
+            headers: {
+                Accept: 'text/html,application/xhtml+xml',
+                'Accept-Language': 'fr-FR,fr;q=0.9,en;q=0.8',
+                'User-Agent': 'Mozilla/5.0 (compatible; DeliveryTracker/1.0)',
+            },
+        }, {
+            provider: 'Paack tracking',
+            timeoutMs: this.timeoutMs,
+            maxBytes: MAX_RESPONSE_BYTES,
+            redirect: 'manual',
+            fetcher: this.fetcher,
+            allowHttpError: true,
+        });
+        if (response.status === 404 || (response.status >= 300 && response.status < 400)) {
+            throw new NotFoundError('Paack');
+        }
+        if (!response.ok)
+            throw new UpstreamHttpError('Paack tracking', response.status);
+        return parsePaackTrackingHtml(decodeText(bytes), trackingNumber);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new PaackTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'paack',
+        steps: ['direct'],
+        track: async (input) => {
+            const postcode = input.postcode?.trim() ?? '';
+            if (!postcode)
+                throw new InputRequiredError('Paack', 'the delivery postcode');
+            return tracker.fetch(input.number, postcode);
+        },
+    };
+};