@tomtom-org/maps-sdk 0.45.4 → 0.45.6

package/core/dist/index.d.ts

@@ -381,7 +381,7 @@ export declare const bboxFromCoordsArray: (coordinates: Position[] | undefined)
  *   key: 'key',
  *   locations: [[4.9, 52.3], [4.5, 51.9]]
  * });
- * const routeBbox = bboxFromGeoJSON(route.routes[0].geometry);
+ * const routeBbox = bboxFromGeoJSON(route.features[0].geometry);
  * // Returns bbox containing the entire route
  *
  * // From an array of GeoJSON objects
@@ -400,6 +400,39 @@ export declare const bboxFromGeoJSON: (hasBBox: HasBBox) => OptionalBBox;
  */
 export declare const bboxOnlyIfWithArea: (bbox: OptionalBBox) => OptionalBBox;
 
+/**
+ * Interpolates the cumulative traveled distance and time at an arbitrary point on the route path.
+ *
+ * Uses the route's `progress` array to linearly interpolate between the two bracketing
+ * {@link RouteProgressPoint} entries that surround the requested `pathIndex`.
+ *
+ * @param route The route whose `properties.progress` will be used for interpolation.
+ *              The progress array must cover the requested index (i.e. the first entry's
+ *              `pointIndex` must be ≤ `pathIndex` and the last's must be ≥ `pathIndex`).
+ * @param pathIndex Zero-based index into the route's coordinate array.
+ * @returns Interpolated {@link RouteProgressAtPoint}, or `undefined` when:
+ *   - the route has no `progress` data
+ *   - `pathIndex` is outside `[0, coordinates.length - 1]`
+ *   - `pathIndex` falls outside the range covered by the progress entries
+ *   - any required distance or time value is missing from the bracketing entries
+ *
+ * @example
+ * ```typescript
+ * const progress = route.properties.progress;
+ * // progress = [
+ * //   { pointIndex: 0,  distanceInMeters: 0,    travelTimeInSeconds: 0   },
+ * //   { pointIndex: 50, distanceInMeters: 2500,  travelTimeInSeconds: 120 },
+ * //   { pointIndex: 100,distanceInMeters: 5000,  travelTimeInSeconds: 300 }
+ * // ]
+ *
+ * const result = calculateProgressAtRoutePoint(route, 25);
+ * // result = { distanceInMeters: 1250, travelTimeInSeconds: 60 }
+ * ```
+ *
+ * @group Utils
+ */
+export declare const calculateProgressAtRoutePoint: (route: Route, pathIndex: number) => RouteProgressAtPoint | undefined;
+
 /**
  * Traffic incident cause based on TPEG2-TEC standard.
  *
@@ -1839,6 +1872,61 @@ export declare interface FeatureCollectionWithProperties<G extends Geometry | nu
     properties?: FeatureCollectionProps;
 }
 
+/**
+ * Finds the best index to insert a new waypoint into an existing route.
+ *
+ * This function determines the optimal position to insert a new waypoint among existing waypoints
+ * by finding where it fits most naturally along the route line. The algorithm:
+ * 1. Projects each existing waypoint onto the route line to find their closest points
+ * 2. Projects the new waypoint onto the route line
+ * 3. Determines where the new waypoint fits based on its position along the route
+ *
+ * @param route The existing calculated route Feature with LineString geometry
+ * @param existingWaypoints Array of existing waypoints in order (origin, intermediate waypoints, destination)
+ * @param newWaypoint The new waypoint to insert
+ * @returns The index where the new waypoint should be inserted (0 means insert at the beginning,
+ *          existingWaypoints.length means append at the end)
+ *
+ * @remarks
+ * - If the route has no coordinates, returns 0
+ * - If there are fewer than 2 existing waypoints, returns 0
+ * - The function finds where the new waypoint naturally fits along the route's progression
+ * - This creates a more streamlined route by minimizing detours
+ *
+ * @example
+ * ```typescript
+ * const route: Route = {
+ *   type: 'Feature',
+ *   id: 'route-1',
+ *   geometry: {
+ *     type: 'LineString',
+ *     coordinates: [[4.9, 52.3], [4.95, 52.35], [5.0, 52.4]]
+ *   },
+ *   properties: { ... },
+ *   bbox: [4.9, 52.3, 5.0, 52.4]
+ * };
+ *
+ * const waypoints: WaypointLike[] = [
+ *   [4.9, 52.3],   // origin
+ *   [5.0, 52.4]    // destination
+ * ];
+ *
+ * const newWaypoint: WaypointLike = [4.95, 52.35];
+ *
+ * const insertIndex = findBestWaypointInsertionIndex(route, waypoints, newWaypoint);
+ * // Returns: 1 (insert between origin and destination)
+ *
+ * const updatedWaypoints = [
+ *   ...waypoints.slice(0, insertIndex),
+ *   newWaypoint,
+ *   ...waypoints.slice(insertIndex)
+ * ];
+ * ```
+ *
+ * @group Utils
+ */
+export declare const findBestWaypointInsertionIndex: (route: Route, existingWaypoints: WaypointLike[], newWaypoint: WaypointLike) => number;
+
 /**
  * Formatting is based on the number of meters passed and unit type. Less meters more precision.
  * @example
@@ -1916,7 +2004,7 @@ export declare const formatDistance: (meters: number, options?: DistanceDisplayU
  *
  * // Route travel time
  * const route = await calculateRoute({ ... });
- * const travelTime = formatDuration(route.routes[0].summary.travelTimeInSeconds);
+ * const travelTime = formatDuration(route.features[0].summary.travelTimeInSeconds);
  * console.log(`Estimated time: ${travelTime}`);
  * // Output: "Estimated time: 2 hr 15 min"
  * ```
@@ -2022,6 +2110,36 @@ export declare type GeometryDataSource = {
     id: string;
 };
 
+/**
+ * Returns the geographic coordinate and cumulative progress values at the point along a route
+ * identified by a {@link RouteProgressQuery}.
+ *
+ * @param route The route to query. Must contain `properties.progress` data.
+ * @param query A discriminated union — provide exactly one of:
+ *   - `{ traveledTimeInSeconds }` — elapsed seconds from route start
+ *   - `{ traveledDistanceInMeters }` — meters traveled from route start
+ *   - `{ clockTime }` — absolute `Date`; elapsed seconds are derived from `route.summary.departureTime`
+ * @returns Interpolated {@link RouteCoordinateAtProgress}, or `undefined` when:
+ *   - the route has no `progress` data
+ *   - `clockTime` is before the route departure time
+ *   - the progress data is incomplete for the requested position
+ *
+ * @example
+ * ```typescript
+ * // By elapsed time
+ * const pos = getCoordinateAtRouteProgress(route, { traveledTimeInSeconds: 600 });
+ *
+ * // By distance
+ * const pos = getCoordinateAtRouteProgress(route, { traveledDistanceInMeters: 5000 });
+ *
+ * // By clock time
+ * const pos = getCoordinateAtRouteProgress(route, { clockTime: new Date('2025-06-01T09:30:00Z') });
+ * ```
+ *
+ * @group Utils
+ */
+export declare const getCoordinateAtRouteProgress: (route: Route, query: RouteProgressQuery) => RouteCoordinateAtProgress | undefined;
+
 /**
  * Extracts the lng-lat position from various input formats.
  *
@@ -2162,6 +2280,34 @@ export declare type GetPositionOptions = {
  */
 export declare const getPositionStrict: (hasLngLat: HasLngLat, options?: GetPositionOptions) => Position;
 
+/**
+ * Returns the geographic coordinate and cumulative progress values at the point on a route
+ * nearest to the given location.
+ *
+ * Projects `point` onto the route line using `nearestPointOnLine`, then linearly interpolates
+ * the progress data at the snapped position between the two bracketing route vertices.
+ *
+ * @param route The route to query. Must contain `properties.progress` data.
+ * @param point The reference location to snap to the route.
+ * @returns Interpolated {@link RouteCoordinateAtProgress} at the nearest point, or `undefined` when:
+ *   - the route has no progress data
+ *   - the route has fewer than 2 coordinates
+ *   - the progress data is incomplete for the snapped position
+ *
+ * @example
+ * ```typescript
+ * const result = getProgressAtNearestRoutePoint(route, { lng: 4.92, lat: 52.32 });
+ * if (result) {
+ *   console.log(`Nearest point: [${result.position}]`);
+ *   console.log(`${result.distanceInMeters} m from route start`);
+ *   console.log(`${result.travelTimeInSeconds} s travel time from route start`);
+ * }
+ * ```
+ *
+ * @group Utils
+ */
+export declare const getProgressAtNearestRoutePoint: (route: Route, point: HasLngLat) => RouteCoordinateAtProgress | undefined;
+
 /**
  * Determines the type of geographic input (waypoint or path).
  *
@@ -2176,6 +2322,90 @@ export declare const getPositionStrict: (hasLngLat: HasLngLat, options?: GetPosi
  */
 export declare const getRoutePlanningLocationType: (routePlanningLocation: RoutePlanningLocation) => RoutePlanningLocationType;
 
+/**
+ * Calculates progress measurements for a segment between two arbitrary points on the route path.
+ *
+ * Calls {@link calculateProgressAtRoutePoint} for both indices and exposes the start and end
+ * measurements together with the delta (distance and time covered between them).
+ *
+ * @param route The route whose `properties.progress` will be used for interpolation.
+ * @param startPathIndex Zero-based index of the segment start in the route's coordinate array.
+ * @param endPathIndex Zero-based index of the segment end in the route's coordinate array.
+ * @returns A {@link RouteSegmentProgress} object, or `undefined` when either index cannot
+ *          be interpolated (see {@link calculateProgressAtRoutePoint} for the full list of conditions).
+ *
+ * @example
+ * ```typescript
+ * const result = getRouteProgressBetween(route, 10, 60);
+ * if (result) {
+ *   console.log(`Segment starts ${result.start.distanceInMeters} m from route origin`);
+ *   console.log(`Segment ends   ${result.end.distanceInMeters} m from route origin`);
+ *   console.log(`Segment length ${result.delta.distanceInMeters} m`);
+ *   console.log(`Segment takes  ${result.delta.travelTimeInSeconds} s`);
+ * }
+ * ```
+ *
+ * @group Utils
+ */
+export declare const getRouteProgressBetween: (route: Route, startPathIndex: number, endPathIndex: number) => RouteSegmentProgress | undefined;
+
+/**
+ * Calculates progress measurements for a route section.
+ *
+ * Convenience wrapper around {@link getRouteProgressBetween} that accepts a {@link SectionProps}
+ * directly, using its `startPointIndex` and `endPointIndex` as the segment bounds.
+ *
+ * @param route The route whose `properties.progress` will be used for interpolation.
+ * @param section The section whose start and end point indices define the segment.
+ * @returns A {@link RouteSegmentProgress} object, or `undefined` when either index cannot
+ *          be interpolated (see {@link calculateProgressAtRoutePoint} for the full list of conditions).
+ *
+ * @example
+ * ```typescript
+ * const section = route.properties.sections.countries[0];
+ * const result = getRouteProgressForSection(route, section);
+ * if (result) {
+ *   console.log(`Section starts ${result.start.distanceInMeters} m from route origin`);
+ *   console.log(`Section ends   ${result.end.distanceInMeters} m from route origin`);
+ *   console.log(`Section length ${result.delta.distanceInMeters} m`);
+ *   console.log(`Section takes  ${result.delta.travelTimeInSeconds} s`);
+ * }
+ * ```
+ *
+ * @group Utils
+ */
+export declare const getRouteProgressForSection: (route: Route, section: SectionProps) => RouteSegmentProgress | undefined;
+
+/**
+ * Calculates the bounding box for a route section.
+ *
+ * This function computes a bbox by sampling coordinates from the section at three key points:
+ * - Start point (startPointIndex)
+ * - Middle point (midpoint between start and end)
+ * - End point (endPointIndex)
+ *
+ * @param route The route containing the section
+ * @param section The section to calculate the bbox for
+ * @returns The bounding box as [minLng, minLat, maxLng, maxLat], or `undefined` if the section or route is invalid
+ *
+ * @remarks
+ * - Samples three points for efficiency while maintaining good accuracy
+ * - Returns `undefined` if the route has no coordinates or section indices are invalid
+ * - Uses existing bbox utilities for consistent calculation
+ *
+ * @example
+ * ```typescript
+ * const section = route.properties.sections.countries[0];
+ * // section = { id: 'section-1', startPointIndex: 0, endPointIndex: 3, countryCodeISO3: 'NLD' }
+ *
+ * const bbox = getSectionBBox(route, section);
+ * // Returns: [minLng, minLat, maxLng, maxLat] spanning the section, or undefined
+ * ```
+ *
+ * @group Utils
+ */
+export declare const getSectionBBox: (route: Route, section: SectionProps) => OptionalBBox;
+
 /**
  * Global configuration for the TomTom Maps SDK.
  *
@@ -3759,6 +3989,20 @@ export declare type Route<P extends RouteProps = RouteProps> = Omit<Feature<Line
     bbox: BBox;
 };
 
+/**
+ * Geographic coordinate and cumulative progress values at a specific point along a route.
+ *
+ * @group Utils
+ */
+export declare type RouteCoordinateAtProgress = {
+    /** Geographic position as a GeoJSON `[longitude, latitude]` coordinate. */
+    position: Position;
+    /** Cumulative travel time in seconds from the route start. */
+    travelTimeInSeconds: number;
+    /** Cumulative distance in meters from the route start. */
+    distanceInMeters: number;
+};
+
 /**
  * Route path point and its metadata.
  * @group Route
@@ -3813,49 +4057,75 @@ export declare type RoutePlanningLocation = WaypointLike | PathLike;
 export declare type RoutePlanningLocationType = 'waypoint' | 'path';
 
 /**
- * Array of progress points along the route path.
+ * Cumulative distance and time measurements at a position along the route.
  *
- * Provides distance and time information at key points along the route.
- * This field is included when `extendedRouteRepresentations` is requested.
+ * Both fields are optional because a progress entry may omit either value.
+ * Use {@link RouteProgressAtPoint} for the resolved (always-present) equivalent
+ * returned by interpolation utilities.
  *
- * @remarks
- * - Always contains entries for the first and last points in the route
- * - Progress for intermediate points can be linearly interpolated between explicitly defined points
- * - Use the Haversine formula for distance calculations between points
+ * @group Route
+ */
+export declare type RouteProgress = {
+    /**
+     * Cumulative travel time in seconds from the route start.
+     */
+    travelTimeInSeconds?: number;
+    /**
+     * Cumulative distance in meters from the route start.
+     */
+    distanceInMeters?: number;
+};
+
+/**
+ * Resolved distance and time measurements at an interpolated position on the route path.
  *
- * @example
- * ```typescript
- * const progress: RouteProgress = [
- *   { pointIndex: 0, travelTimeInSeconds: 0, distanceInMeters: 0 },
- *   { pointIndex: 50, travelTimeInSeconds: 120, distanceInMeters: 2500 },
- *   { pointIndex: 100, travelTimeInSeconds: 300, distanceInMeters: 5000 }
- * ];
- * ```
+ * Both fields are required because this type is only produced when interpolation
+ * can be fully resolved (i.e. the bracketing progress entries both carry valid values).
  *
  * @group Route
  */
-export declare type RouteProgress = RouteProgressPoint[];
+export declare type RouteProgressAtPoint = Required<RouteProgress>;
 
 /**
- * Progress information for a specific point along the route.
+ * Progress measurements tied to a specific coordinate on the route path.
+ *
+ * Extends {@link RouteProgress} with a `pointIndex` that identifies the
+ * corresponding entry in the route's coordinate array.
  *
- * Contains cumulative distance and time measurements from the route start to this point.
+ * @remarks
+ * - The `progress` array on a route always contains entries for the first and last points
+ * - Progress for intermediate points can be linearly interpolated between entries
+ *
+ * @example
+ * ```typescript
+ * const points: RouteProgressPoint[] = [
+ *   { pointIndex: 0,   travelTimeInSeconds: 0,   distanceInMeters: 0    },
+ *   { pointIndex: 50,  travelTimeInSeconds: 120,  distanceInMeters: 2500 },
+ *   { pointIndex: 100, travelTimeInSeconds: 300,  distanceInMeters: 5000 }
+ * ];
+ * ```
  *
  * @group Route
  */
-export declare type RouteProgressPoint = {
+export declare type RouteProgressPoint = RouteProgress & {
     /**
      * Zero-based index of this point in the route's coordinate array.
      */
     pointIndex: number;
-    /**
-     * Cumulative travel time in seconds from the route start to this point.
-     */
-    travelTimeInSeconds?: number;
-    /**
-     * Cumulative distance in meters from the route start to this point.
-     */
-    distanceInMeters?: number;
+};
+
+/**
+ * Discriminated union describing how to identify a position along a route.
+ * Provide exactly one of the three variants.
+ *
+ * @group Utils
+ */
+export declare type RouteProgressQuery = {
+    traveledTimeInSeconds: number;
+} | {
+    traveledDistanceInMeters: number;
+} | {
+    clockTime: Date;
 };
 
 /**
@@ -3893,10 +4163,10 @@ export declare type RouteProps = {
     /**
      * Distance and time progress at key points along the route.
      *
-     * Only present when extended route representations are requested.
-     * Useful for displaying progress information or calculating intermediate times.
+     * * Present when extended route representations are requested, which is the default for route calculations.
+     * * Useful for displaying progress information or calculating intermediate times.
      */
-    progress?: RouteProgress;
+    progress?: RouteProgressPoint[];
     /**
      * Index of this route in the collection of alternatives.
      *
@@ -3943,6 +4213,20 @@ export declare type Routes<P extends RouteProps = RouteProps, FeatureCollectionP
     bbox?: BBox;
 };
 
+/**
+ * Progress measurements for a segment between two arbitrary points on the route path.
+ *
+ * @group Route
+ */
+export declare type RouteSegmentProgress = {
+    /** Progress at the start point. */
+    start: RouteProgressAtPoint;
+    /** Progress at the end point. */
+    end: RouteProgressAtPoint;
+    /** Difference between end and start (distance and time covered by the segment). */
+    delta: RouteProgressAtPoint;
+};
+
 /**
  * Complete summary information for an entire route.
  *
@@ -4751,4 +5035,49 @@ export declare type WaypointProps = {
  */
 export declare type Waypoints<T extends Anything = Anything> = FeatureCollection<Point, WaypointProps & T>;
 
+/**
+ * Returns a new array of waypoints with the new waypoint inserted at the optimal position.
+ *
+ * This is a convenience function that combines finding the best insertion index and
+ * inserting the waypoint in one step. It uses {@link findBestWaypointInsertionIndex}
+ * to determine where the waypoint fits most naturally along the route.
+ *
+ * @param route The existing calculated route Feature with LineString geometry
+ * @param existingWaypoints Array of existing waypoints in order (origin, intermediate waypoints, destination)
+ * @param newWaypoint The new waypoint to insert
+ * @returns A new array with the waypoint inserted at the optimal position
+ *
+ * @remarks
+ * - Returns a new array; does not modify the original waypoints array
+ * - Uses the same logic as findBestWaypointInsertionIndex to determine position
+ * - Handles all edge cases (empty route, fewer than 2 waypoints)
+ *
+ * @example
+ * ```typescript
+ * const route: Route = {
+ *   type: 'Feature',
+ *   id: 'route-1',
+ *   geometry: {
+ *     type: 'LineString',
+ *     coordinates: [[4.9, 52.3], [4.95, 52.35], [5.0, 52.4]]
+ *   },
+ *   properties: { ... },
+ *   bbox: [4.9, 52.3, 5.0, 52.4]
+ * };
+ *
+ * const waypoints: WaypointLike[] = [
+ *   [4.9, 52.3],   // origin
+ *   [5.0, 52.4]    // destination
+ * ];
+ *
+ * const newWaypoint: WaypointLike = [4.95, 52.35];
+ *
+ * const updatedWaypoints = withInsertedWaypoint(route, waypoints, newWaypoint);
+ * // Returns: [[4.9, 52.3], [4.95, 52.35], [5.0, 52.4]]
+ * ```
+ *
+ * @group Utils
+ */
+export declare const withInsertedWaypoint: (route: Route, existingWaypoints: WaypointLike[], newWaypoint: WaypointLike) => WaypointLike[];
+
 export { }

package/core/package.json

@@ -23,6 +23,7 @@
     "geojson": "^0.5.0"
   },
   "peerDependencies": {
+    "@turf/turf": "catalog:",
     "lodash-es": "catalog:"
   },
   "devDependencies": {

package/map/dist/THIRD_PARTY.txt

@@ -1,107 +1 @@
-Name: @turf/helpers
-Version: 7.3.4
-License: MIT
-Private: false
-Description: Provides helper functions to create GeoJSON features, like points, lines, or areas on a map.
-Repository: git://github.com/Turfjs/turf.git
-Homepage: https://github.com/Turfjs/turf
-Author: Turf Authors
-Contributors:
-  Tom MacWright <@tmcw>
-  Stefano Borghi <@stebogit>
-  Denis Carriere <@DenisCarriere>
-  William Nordmann <@wnordmann>
-License Text:
-===
-
-The MIT License (MIT)
-
-Copyright (c) 2017 TurfJS
-
-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.
-
----
-
-Name: @turf/invariant
-Version: 7.3.4
-License: MIT
-Private: false
-Description: Lightweight utility for input validation and data extraction in Turf.js. Ensures GeoJSON inputs are in the correct format and extracts specific components like coordinates or geometries.
-Repository: git://github.com/Turfjs/turf.git
-Homepage: https://github.com/Turfjs/turf
-Author: Turf Authors
-Contributors:
-  Tom MacWright <@tmcw>
-  Denis Carriere <@DenisCarriere>
-License Text:
-===
-
-The MIT License (MIT)
-
-Copyright (c) 2017 TurfJS
-
-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.
-
----
-
-Name: @turf/bearing
-Version: 7.3.4
-License: MIT
-Private: false
-Description: Takes two points and finds the geographic bearing between them.
-Repository: git://github.com/Turfjs/turf.git
-Homepage: https://github.com/Turfjs/turf
-Author: Turf Authors
-License Text:
-===
-
-The MIT License (MIT)
-
-Copyright (c) 2017 TurfJS
-
-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.
+No third parties dependencies