universal-parcel-scraper 0.0.0-stage → 0.2.0

package/dist/carriers/amazon-logistics/numbers.json

@@ -0,0 +1,307 @@
+{
+  "carrier": "amazon-logistics",
+  "records": [
+    {
+      "number": "AT0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the AT marketplace prefix."
+    },
+    {
+      "number": "BE0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the BE marketplace prefix."
+    },
+    {
+      "number": "CH0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the CH marketplace prefix."
+    },
+    {
+      "number": "DE0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the DE marketplace prefix."
+    },
+    {
+      "number": "ES0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the ES marketplace prefix."
+    },
+    {
+      "number": "FR0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the FR marketplace prefix."
+    },
+    {
+      "number": "FR1234567890",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "official_shape",
+      "shapeConfirmed": "2026-09-10",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Made-up number that follows the published format."
+    },
+    {
+      "number": "GB0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the GB marketplace prefix."
+    },
+    {
+      "number": "IE0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the IE marketplace prefix."
+    },
+    {
+      "number": "IT0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the IT marketplace prefix."
+    },
+    {
+      "number": "NL0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the NL marketplace prefix."
+    },
+    {
+      "number": "PL0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the PL marketplace prefix."
+    },
+    {
+      "number": "PT0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the PT marketplace prefix."
+    },
+    {
+      "number": "SE0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the SE marketplace prefix."
+    },
+    {
+      "number": "TBA000000000000",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/amazon.json"
+      },
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "TBA000000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "official_shape",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Made-up number that follows the published format."
+    },
+    {
+      "number": "TBA010000000000",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/amazon.json"
+      },
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Open-source project example, not a real shipment."
+    },
+    {
+      "number": "TBA333656997000",
+      "role": "shipment",
+      "evidence": "public_shipment_report",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/issues/2",
+        "date": "2017-08-15"
+      },
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Publicly reported shipment number; the attribution was not independently verified."
+    },
+    {
+      "number": "TBC 000000000000",
+      "role": "shipment",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/amazon.json"
+      },
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "none"
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Amazon Logistics; no rule matches this shape."
+    },
+    {
+      "number": "UK0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "amazon-logistics",
+        "confidence": "high"
+      },
+      "note": "Invented placeholder for the UK marketplace prefix."
+    },
+    {
+      "number": "ZZ0000000001",
+      "role": "shipment",
+      "evidence": "synthetic",
+      "derivedFrom": "invented",
+      "shapeConfirmed": "2026-09-12",
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "low",
+        "candidates": [
+          "colis-prive"
+        ]
+      },
+      "note": "Invented placeholder used as a shape check. Filed under Amazon Logistics, which no rule claims."
+    },
+    {
+      "number": "C1004444443",
+      "role": "quarantined",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/amazon.json"
+      },
+      "quarantine": true,
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "none"
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Amazon Logistics; no rule matches this shape."
+    },
+    {
+      "number": "C1004444444",
+      "role": "quarantined",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/amazon.json"
+      },
+      "quarantine": true,
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "none"
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Amazon Logistics; no rule matches this shape."
+    },
+    {
+      "number": "TBM502887274000",
+      "role": "quarantined",
+      "evidence": "open_source_example",
+      "source": {
+        "url": "https://github.com/jkeen/tracking_number_data/blob/main/couriers/amazon.json"
+      },
+      "quarantine": true,
+      "expect": {
+        "carrier": "unknown",
+        "confidence": "none"
+      },
+      "note": "Open-source project example, not a real shipment. The source attributes it to Amazon Logistics; no rule matches this shape."
+    }
+  ]
+}

package/dist/carriers/amazon-shipping/adapter.d.ts

@@ -0,0 +1,34 @@
+import type { AdapterFactory } from '../../core/adapter/index.js';
+import { IndeterminateError, NotFoundError } from '../../core/errors/index.js';
+import type { CarrierResult } from '../../core/result/index.js';
+export { amazonShippingStatus } from './status.js';
+export interface AmazonShippingOptions {
+    timeoutMs?: number;
+    /** Test seam; production uses the global fetch. */
+    fetcher?: typeof fetch;
+}
+/** A confirmed absence, with a public reason consumers can inspect. */
+export declare class AmazonShippingNotFoundError extends NotFoundError {
+    constructor();
+}
+/**
+ * Amazon recognizes the shipment but will not serve its history any more.
+ * A definite answer that still yields no usable tracking data, so it maps to
+ * the taxonomy's `indeterminate` kind. The host narrows on this class with
+ * `instanceof` to store the history-expired marker and stop scheduling syncs.
+ */
+export declare class AmazonShippingHistoryExpiredError extends IndeterminateError {
+    constructor();
+}
+export declare function normalizeAmazonShippingTrackingNumber(raw: string): string;
+export declare function amazonShippingTrackingUrl(rawTrackingNumber: string): string;
+export declare function amazonShippingTrackingApiUrl(rawTrackingNumber: string): string;
+export declare function parseAmazonShippingTrackingResponse(payload: unknown, zone?: string | null, trackingNumber?: string): CarrierResult;
+export declare function amazonShippingTimezone(number: string): string | null;
+export declare class AmazonShippingTracker {
+    #private;
+    readonly timeoutMs: number;
+    constructor(options?: number | AmazonShippingOptions);
+    fetch(rawTrackingNumber: string): Promise<CarrierResult>;
+}
+export declare const adapter: AdapterFactory;

package/dist/carriers/amazon-shipping/adapter.js

@@ -0,0 +1,292 @@
+import { DateTime } from 'luxon';
+import { amazonShippingOrigin, amazonShippingUrl } from '../../core/catalog/index.js';
+import { isAmazonTrackingNumber } from '../../core/detection/index.js';
+import { IndeterminateError, InputRequiredError, NotFoundError, SchemaError } from '../../core/errors/index.js';
+import { cleanScalar, fetchBounded, parseJsonBytes } from '../../core/transport/index.js';
+import { isRecord } from '../../core/types.js';
+import { classifyStatus, statusKey } from './status.js';
+const PROVIDER = 'Amazon Shipping';
+const DEFAULT_TIMEOUT_MS = 15_000;
+const MAX_RESPONSE_BYTES = 2_000_000;
+const MAX_EVENTS_TO_INSPECT = 500;
+const MAX_EVENTS_TO_RETURN = 100;
+export { amazonShippingStatus } from './status.js';
+/** A confirmed absence, with a public reason consumers can inspect. */
+export class AmazonShippingNotFoundError extends NotFoundError {
+    constructor() {
+        super(PROVIDER, undefined, { reason: 'shipment_not_found' });
+        this.name = 'AmazonShippingNotFoundError';
+    }
+}
+/**
+ * Amazon recognizes the shipment but will not serve its history any more.
+ * A definite answer that still yields no usable tracking data, so it maps to
+ * the taxonomy's `indeterminate` kind. The host narrows on this class with
+ * `instanceof` to store the history-expired marker and stop scheduling syncs.
+ */
+export class AmazonShippingHistoryExpiredError extends IndeterminateError {
+    constructor() {
+        super(PROVIDER, 'Amazon Shipping tracking history has expired', { reason: 'history_expired' });
+        this.name = 'AmazonShippingHistoryExpiredError';
+    }
+}
+function eventDescription(raw, classified) {
+    const summary = isRecord(raw.statusSummary) ? raw.statusSummary : {};
+    const key = [summary.localisedStringId, raw.eventCode, raw.subReasonCode]
+        .map(statusKey)
+        .join(' ');
+    if (key.includes('creationconfirmed'))
+        return 'Shipment information received';
+    if (key.includes('pickupdone') || key.includes('detailpickedup'))
+        return 'Shipment picked up';
+    if (key.includes('arrivedatdeliverycenter'))
+        return 'Arrived at delivery center';
+    if (key.includes('arrivedatsortcenter'))
+        return 'Arrived at sorting center';
+    if (key.includes('departed'))
+        return 'Departed facility';
+    return classified.description;
+}
+/**
+ * Local time policy, deliberately not one of `core/time`'s helpers: the tracker
+ * mixes ISO-8601, RFC 2822 and US long-form dates, and when `zone` is null (a
+ * `TBA` number, which identifies no country) an offset-free value must be
+ * rejected rather than stamped with a guess.
+ */
+function parseDate(value, zone) {
+    const raw = cleanScalar(value, 100);
+    if (!raw)
+        return null;
+    const isoHasZone = /(?:Z|[+-]\d{2}:?\d{2})$/i.test(raw);
+    if (!zone && !isoHasZone && !/[+-][0-9]{4}$|GMT|UTC/i.test(raw))
+        return null;
+    const candidates = [
+        DateTime.fromISO(raw, { setZone: isoHasZone, zone: zone ?? 'UTC' }),
+        DateTime.fromRFC2822(raw, { setZone: true }),
+        ...[
+            'LLL d, yyyy, h:mm:ss a',
+            'LLL d, yyyy, h:mm a',
+            'LLLL d, yyyy, h:mm:ss a',
+            'LLLL d, yyyy, h:mm a',
+        ].map((format) => DateTime.fromFormat(raw, format, {
+            locale: 'en-US',
+            zone: zone ?? 'UTC',
+        })),
+    ];
+    const parsed = candidates.find((candidate) => candidate.isValid);
+    if (!parsed)
+        return null;
+    const iso = parsed.toISO({ suppressMilliseconds: true });
+    return iso ? { iso, timestamp: parsed.toMillis() } : null;
+}
+function parseSerializedRecord(value, field) {
+    if (isRecord(value))
+        return value;
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new SchemaError(PROVIDER, `Amazon Shipping returned an invalid ${field}`);
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (isRecord(parsed))
+            return parsed;
+    }
+    catch (error) {
+        throw new SchemaError(PROVIDER, `Amazon Shipping returned an invalid ${field}`, { cause: error });
+    }
+    throw new SchemaError(PROVIDER, `Amazon Shipping returned an invalid ${field}`);
+}
+function optionalSerializedRecord(value, field) {
+    if (value == null || value === 'null' || value === '')
+        return null;
+    return parseSerializedRecord(value, field);
+}
+function isNotFoundError(value) {
+    if (!isRecord(value))
+        return false;
+    const key = `${statusKey(value.errorCode)} ${statusKey(value.errorMessage)}`;
+    return key.includes('trackingidnotfound') || key.includes('invalidtrackingid');
+}
+/** City, region and country only; the same object also carries the street and postcode. */
+function location(raw) {
+    if (!isRecord(raw))
+        return '';
+    const values = [raw.city, raw.stateProvince, raw.countryCode]
+        .map((value) => cleanScalar(value, 100))
+        .filter((value, index, all) => value
+        && all.findIndex((candidate) => candidate.toLocaleLowerCase('en-US')
+            === value.toLocaleLowerCase('en-US')) === index);
+    return values.join(', ').slice(0, 250);
+}
+function providerCode(value) {
+    const code = cleanScalar(value, 64);
+    return /^[A-Za-z0-9_-]+$/.test(code) ? code : '';
+}
+function eventRecords(value) {
+    const events = value?.eventHistory;
+    return Array.isArray(events) ? events.filter(isRecord) : [];
+}
+function parseEvent(raw, sourceIndex, zone) {
+    const summary = isRecord(raw.statusSummary) ? raw.statusSummary : {};
+    const classified = classifyStatus(summary.localisedStringId, raw.eventCode, raw.subReasonCode);
+    const time = parseDate(raw.eventTime, zone);
+    const code = providerCode(raw.eventCode);
+    if (!time && !code && classified.status === 'unknown')
+        return null;
+    const eventLocation = location(raw.location);
+    return {
+        classified,
+        timestamp: time?.timestamp ?? Number.NEGATIVE_INFINITY,
+        sourceIndex,
+        event: {
+            ...(time ? { time: time.iso } : {}),
+            ...(eventLocation ? { location: eventLocation } : {}),
+            description: eventDescription(raw, classified),
+            stage: classified.stage,
+            ...(code ? { provider_code: code } : {}),
+        },
+    };
+}
+function metadataValue(metadata, field) {
+    const value = metadata[field];
+    if (!isRecord(value))
+        return value;
+    return value.stringValue ?? value.date ?? value.value;
+}
+export function normalizeAmazonShippingTrackingNumber(raw) {
+    const value = raw.trim().toLocaleUpperCase('en-US').replace(/[\s.-]/g, '');
+    if (!isAmazonTrackingNumber(value)) {
+        throw new InputRequiredError(PROVIDER, 'a European country prefix and 10 digits, or TBA and 12 digits', 'Amazon tracking numbers need a European country prefix and 10 digits, or TBA and 12 digits');
+    }
+    return value;
+}
+export function amazonShippingTrackingUrl(rawTrackingNumber) {
+    const trackingNumber = normalizeAmazonShippingTrackingNumber(rawTrackingNumber);
+    return amazonShippingUrl(trackingNumber);
+}
+export function amazonShippingTrackingApiUrl(rawTrackingNumber) {
+    const trackingNumber = normalizeAmazonShippingTrackingNumber(rawTrackingNumber);
+    return `${amazonShippingOrigin(trackingNumber)}/api/tracker/${encodeURIComponent(trackingNumber)}`;
+}
+export function parseAmazonShippingTrackingResponse(payload, zone = 'Europe/Paris', trackingNumber) {
+    if (!isRecord(payload)) {
+        throw new SchemaError(PROVIDER, 'Amazon Shipping returned an invalid tracking response');
+    }
+    const progress = parseSerializedRecord(payload.progressTracker, 'progress tracker');
+    const errors = Array.isArray(progress.errors) ? progress.errors : [];
+    if (errors.some(isNotFoundError))
+        throw new AmazonShippingNotFoundError();
+    // The endpoint is shipment-scoped but does not normally echo identity. Reject a
+    // contradictory ID when supplied; never accept a generic page or status alone.
+    const identitySummary = isRecord(progress.summary) ? progress.summary : {};
+    const identityMetadata = isRecord(identitySummary.metadata) ? identitySummary.metadata : {};
+    for (const identity of [payload.trackingId, payload.trackingID, progress.trackingId, metadataValue(identityMetadata, 'trackingId')]) {
+        if (trackingNumber && identity != null && String(identity).toUpperCase() !== trackingNumber) {
+            throw new SchemaError(PROVIDER, 'Amazon Shipping returned a different tracking number');
+        }
+    }
+    if (!['SWA', 'MCF'].includes(String(progress.trackerSource)))
+        throw new AmazonShippingNotFoundError();
+    if (errors.length && errors.every((error) => isRecord(error) && error.errorCode === 'SHIPMENT_OLDER_THAN_SUPPORTED_AGE')) {
+        throw new AmazonShippingHistoryExpiredError();
+    }
+    if (errors.length)
+        throw new SchemaError(PROVIDER, 'Amazon Shipping returned tracking errors');
+    const history = optionalSerializedRecord(payload.eventHistory, 'event history');
+    const seen = new Set();
+    const parsedEvents = [];
+    eventRecords(history).slice(0, MAX_EVENTS_TO_INSPECT).forEach((raw, index) => {
+        const parsed = parseEvent(raw, index, zone);
+        if (!parsed)
+            return;
+        const identity = JSON.stringify([
+            parsed.event.time ?? '',
+            parsed.event.location ?? '',
+            parsed.event.provider_code ?? '',
+            parsed.event.description ?? '',
+        ]);
+        if (seen.has(identity))
+            return;
+        seen.add(identity);
+        parsedEvents.push(parsed);
+    });
+    parsedEvents.sort((left, right) => (right.timestamp - left.timestamp || right.sourceIndex - left.sourceIndex));
+    const events = parsedEvents.slice(0, MAX_EVENTS_TO_RETURN).map(({ event }) => event);
+    const summary = isRecord(progress.summary) ? progress.summary : {};
+    const metadata = isRecord(summary.metadata) ? summary.metadata : {};
+    const tags = Array.isArray(summary.containerStatusTags)
+        ? summary.containerStatusTags.join(' ')
+        : '';
+    const current = classifyStatus(metadataValue(metadata, 'trackingStatus'), summary.status, tags);
+    const latestKnown = parsedEvents.find((item) => item.classified.status !== 'unknown');
+    const active = current.status !== 'unknown' ? current : latestKnown?.classified;
+    if (!active) {
+        throw new SchemaError(PROVIDER, 'Amazon Shipping returned incomplete tracking details');
+    }
+    const fallbackUpdate = [
+        'deliveryDate',
+        'pickupEventDate',
+        'creationDate',
+    ].map((field) => parseDate(metadataValue(metadata, field), zone)).find(Boolean) ?? null;
+    const expected = parseDate(progress.expectedDeliveryDate
+        ?? metadataValue(metadata, 'expectedDeliveryDate')
+        ?? metadataValue(metadata, 'promisedDeliveryDate'), zone);
+    return {
+        status: active.status,
+        current_stage: active.stage,
+        last_status_text: active.description,
+        last_update: events[0]?.time ?? fallbackUpdate?.iso ?? null,
+        expected_delivery: expected?.iso.slice(0, 10) ?? null,
+        ...(zone ? { timezone: zone } : {}),
+        events,
+    };
+}
+export function amazonShippingTimezone(number) {
+    if (number.startsWith('TBA'))
+        return null; // A US number cannot establish a local timezone.
+    const zones = {
+        UK: 'Europe/London', GB: 'Europe/London', IE: 'Europe/Dublin', PT: 'Europe/Lisbon',
+        FI: 'Europe/Helsinki', EE: 'Europe/Tallinn', LV: 'Europe/Riga', LT: 'Europe/Vilnius',
+        GR: 'Europe/Athens', CY: 'Asia/Nicosia', RO: 'Europe/Bucharest', BG: 'Europe/Sofia',
+        IS: 'Atlantic/Reykjavik', TR: 'Europe/Istanbul',
+    };
+    return zones[number.slice(0, 2)] ?? 'Europe/Paris';
+}
+export class AmazonShippingTracker {
+    timeoutMs;
+    #fetcher;
+    constructor(options = {}) {
+        const { timeoutMs = DEFAULT_TIMEOUT_MS, fetcher } = typeof options === 'number'
+            ? { timeoutMs: options, fetcher: undefined }
+            : options;
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            throw new TypeError('Amazon Shipping timeout must be positive');
+        }
+        this.timeoutMs = timeoutMs;
+        this.#fetcher = fetcher;
+    }
+    async fetch(rawTrackingNumber) {
+        const trackingNumber = normalizeAmazonShippingTrackingNumber(rawTrackingNumber);
+        const { bytes } = await fetchBounded(amazonShippingTrackingApiUrl(trackingNumber), {
+            headers: {
+                Accept: 'application/json',
+                'Accept-Language': 'en-US,en;q=0.9',
+                Referer: amazonShippingTrackingUrl(trackingNumber),
+                'User-Agent': 'Mozilla/5.0 (compatible; DeliveryTracker/1.0)',
+            },
+        }, {
+            provider: 'Amazon Shipping tracking',
+            timeoutMs: this.timeoutMs,
+            maxBytes: MAX_RESPONSE_BYTES,
+            ...(this.#fetcher ? { fetcher: this.#fetcher } : {}),
+        });
+        return parseAmazonShippingTrackingResponse(parseJsonBytes(bytes, PROVIDER), amazonShippingTimezone(trackingNumber), trackingNumber);
+    }
+}
+export const adapter = (environment) => {
+    const tracker = new AmazonShippingTracker({ fetcher: environment.fetcher });
+    return {
+        id: 'amazon-shipping',
+        steps: ['direct'],
+        track: (input) => tracker.fetch(input.number),
+    };
+};