places-autocomplete-svelte 2.2.20 → 2.2.22

package/dist/PlaceAutocomplete.svelte.d.ts

@@ -3,6 +3,11 @@ declare const PlaceAutocomplete: import("svelte").Component<Props, {
     clear: () => void;
     focus: () => void;
     getRequestParams: () => import("./interfaces.js").RequestParams;
+    setRequestParams: (params: Partial<import("./interfaces.js").RequestParams>) => void;
+    setFetchFields: (fields: string[]) => void;
+    getFetchFields: () => string[];
+    setOptions: (options: import("./interfaces.js").ComponentOptions) => void;
+    getOptions: () => import("./interfaces.js").ComponentOptions;
 }, "onResponse" | "onError">;
 type PlaceAutocomplete = ReturnType<typeof PlaceAutocomplete>;
 export default PlaceAutocomplete;

package/dist/gmaps.d.ts

@@ -1,34 +1,82 @@
 import { type Writable } from 'svelte/store';
 import { importLibrary, type APIOptions } from "@googlemaps/js-api-loader";
+/**
+ * Context object for managing Google Maps API initialisation state across components.
+ * Provides reactive stores for initialisation status and error handling, plus a shared promise
+ * to prevent duplicate API loading attempts.
+ * @interface GMapsContext
+ */
 interface GMapsContext {
-    isInitialized: Writable<boolean>;
+    /** Reactive store tracking whether the Google Maps API has been successfully initialised. */
+    isInitialised: Writable<boolean>;
+    /** Reactive store containing any error that occurred during API initialisation. */
     error: Writable<Error | null>;
-    initializationPromise: Promise<void> | null;
+    /** Shared promise for API initialisation, ensuring only one load attempt occurs across all components. */
+    initialisationPromise: Promise<void> | null;
 }
+/**
+ * Re-exported types for external use.
+ * @public
+ */
 export type { GMapsContext, APIOptions };
 /**
- * Creates and sets the Google Maps context with writable stores.
- * This is synchronous and should be called once in a top-level component's script.
+ * Creates and initialises the Google Maps context with reactive stores.
+ * This function should be called once in a top-level parent component (e.g., +layout.svelte)
+ * before any child components attempt to use the Google Maps API.
+ * The function is idempotent - calling it multiple times has no effect after the first call.
+ * @public
+ * @returns {void}
+ * @example
+ * // In +layout.svelte
+ * <script>
+ *   import { setGMapsContext } from './gmaps';
+ *   setGMapsContext();
+ * </script>
  */
 export declare function setGMapsContext(): void;
 /**
- * Retrieves the shared Google Maps context.
- * @returns {GMapsContext} The stores for initialization status and errors.
+ * Retrieves the shared Google Maps context from Svelte's context API.
+ * Must be called after setGMapsContext() has been invoked in a parent component.
+ * @public
+ * @returns {GMapsContext} The context object containing initialisation stores and promise.
+ * @throws {Error} If the context has not been set by a parent component.
  */
 export declare function getGMapsContext(): GMapsContext;
+/**
+ * Checks whether the Google Maps context has been set in the component tree.
+ * Use this to conditionally handle scenarios where context may or may not be available.
+ * @public
+ * @returns {boolean} True if the context exists, false otherwise.
+ */
 export declare function hasGMapsContext(): boolean;
 /**
- * Asynchronously initializes the Google Maps loader using the provided context.
- * This function is idempotent and safe to be called multiple times.
- * @param context - The GMapsContext object.
- * @param options - The options for the JS API loader, including your API key.
- * @returns {Promise<void>}
+ * Asynchronously initialises the Google Maps JavaScript API using the shared context.
+ * This function is idempotent and safe to call multiple times - subsequent calls will
+ * return the same initialisation promise, preventing duplicate API loading.
+ * @public
+ * @param {APIOptions} options - Configuration options for the Google Maps API loader, including API key.
+ * @returns {Promise<void>} A promise that resolves when the API is fully initialised.
+ * @throws {Error} If API initialisation fails (e.g., invalid API key, network issues).
+ * @example
+ * await initialiseGMaps({ key: 'YOUR_API_KEY', v: 'weekly' });
  */
 export declare function initialiseGMaps(options: APIOptions): Promise<void>;
 /**
- * Initializes the Google Maps API without using the context.
- * @param options The options for the JS API loader, including your API key.
- * @returns A promise that resolves when the API is initialized.
+ * Initialises the Google Maps JavaScript API without using the Svelte context system.
+ * Use this when you need standalone initialisation without sharing state across components,
+ * such as in the PlaceAutocomplete component when no parent context provider is available.
+ * @public
+ * @param {APIOptions} options - Configuration options for the Google Maps API loader, including API key.
+ * @returns {Promise<void>} A promise that resolves when the API is initialised.
+ * @throws {Error} If API initialisation fails.
+ * @example
+ * await initialiseGMapsNoContext({ key: 'YOUR_API_KEY', v: 'weekly' });
  */
 export declare function initialiseGMapsNoContext(options: APIOptions): Promise<void>;
+/**
+ * Re-exported from @googlemaps/js-api-loader for convenient access.
+ * Dynamically imports a specific Google Maps library (e.g., 'places', 'maps', 'marker').
+ * @public
+ * @see https://developers.google.com/maps/documentation/javascript/importing-libraries
+ */
 export { importLibrary };

package/dist/gmaps.js

@@ -1,24 +1,42 @@
 import { getContext, setContext } from 'svelte';
 import { writable, get } from 'svelte/store';
 import { setOptions, importLibrary } from "@googlemaps/js-api-loader";
+/**
+ * Unique symbol key for storing the Google Maps context in Svelte's context API.
+ * Using a Symbol ensures the key cannot be accidentally overwritten by other components.
+ * @private
+ */
 const LOADER_CONTEXT_KEY = Symbol('gmaps-loader');
 /**
- * Creates and sets the Google Maps context with writable stores.
- * This is synchronous and should be called once in a top-level component's script.
+ * Creates and initialises the Google Maps context with reactive stores.
+ * This function should be called once in a top-level parent component (e.g., +layout.svelte)
+ * before any child components attempt to use the Google Maps API.
+ * The function is idempotent - calling it multiple times has no effect after the first call.
+ * @public
+ * @returns {void}
+ * @example
+ * // In +layout.svelte
+ * <script>
+ *   import { setGMapsContext } from './gmaps';
+ *   setGMapsContext();
+ * </script>
  */
 export function setGMapsContext() {
     // Only set the context if it doesn't already exist.
     if (getContext(LOADER_CONTEXT_KEY))
         return;
     setContext(LOADER_CONTEXT_KEY, {
-        isInitialized: writable(false),
+        isInitialised: writable(false),
         error: writable(null),
-        initializationPromise: null, // Will be set by the loader function
+        initialisationPromise: null, // Will be set by the loader function
     });
 }
 /**
- * Retrieves the shared Google Maps context.
- * @returns {GMapsContext} The stores for initialization status and errors.
+ * Retrieves the shared Google Maps context from Svelte's context API.
+ * Must be called after setGMapsContext() has been invoked in a parent component.
+ * @public
+ * @returns {GMapsContext} The context object containing initialisation stores and promise.
+ * @throws {Error} If the context has not been set by a parent component.
  */
 export function getGMapsContext() {
     const context = getContext(LOADER_CONTEXT_KEY);
@@ -27,33 +45,43 @@ export function getGMapsContext() {
     }
     return context;
 }
+/**
+ * Checks whether the Google Maps context has been set in the component tree.
+ * Use this to conditionally handle scenarios where context may or may not be available.
+ * @public
+ * @returns {boolean} True if the context exists, false otherwise.
+ */
 export function hasGMapsContext() {
     const context = getContext(LOADER_CONTEXT_KEY);
     return !!context;
 }
 /**
- * Asynchronously initializes the Google Maps loader using the provided context.
- * This function is idempotent and safe to be called multiple times.
- * @param context - The GMapsContext object.
- * @param options - The options for the JS API loader, including your API key.
- * @returns {Promise<void>}
+ * Asynchronously initialises the Google Maps JavaScript API using the shared context.
+ * This function is idempotent and safe to call multiple times - subsequent calls will
+ * return the same initialisation promise, preventing duplicate API loading.
+ * @public
+ * @param {APIOptions} options - Configuration options for the Google Maps API loader, including API key.
+ * @returns {Promise<void>} A promise that resolves when the API is fully initialised.
+ * @throws {Error} If API initialisation fails (e.g., invalid API key, network issues).
+ * @example
+ * await initialiseGMaps({ key: 'YOUR_API_KEY', v: 'weekly' });
  */
 export async function initialiseGMaps(options) {
     // Get the context internally
     const context = getGMapsContext();
-    // If the promise already exists, just await it. Don't re-initialize.
-    if (context.initializationPromise) {
-        return context.initializationPromise;
+    // If initialisation is already in progress or completed, return the existing promise
+    if (context.initialisationPromise) {
+        return context.initialisationPromise;
     }
-    // If it's already marked as initialized (e.g., from a previous page navigation), resolve immediately.
-    if (get(context.isInitialized)) {
+    // If already initialised (e.g., from browser navigation or hot reload), resolve immediately
+    if (get(context.isInitialised)) {
         return Promise.resolve();
     }
-    // Create the promise and store it in the context object.
-    context.initializationPromise = new Promise((resolve, reject) => {
+    // Create a new initialisation promise and store it in the context to prevent duplicate loads
+    context.initialisationPromise = new Promise((resolve, reject) => {
         try {
-            setOptions(options); // Await the setOptions which returns a promise
-            context.isInitialized.set(true);
+            setOptions(options); // Configure the Google Maps API loader with provided options
+            context.isInitialised.set(true);
             resolve();
         }
         catch (e) {
@@ -63,12 +91,18 @@ export async function initialiseGMaps(options) {
             reject(error);
         }
     });
-    return context.initializationPromise;
+    return context.initialisationPromise;
 }
 /**
- * Initializes the Google Maps API without using the context.
- * @param options The options for the JS API loader, including your API key.
- * @returns A promise that resolves when the API is initialized.
+ * Initialises the Google Maps JavaScript API without using the Svelte context system.
+ * Use this when you need standalone initialisation without sharing state across components,
+ * such as in the PlaceAutocomplete component when no parent context provider is available.
+ * @public
+ * @param {APIOptions} options - Configuration options for the Google Maps API loader, including API key.
+ * @returns {Promise<void>} A promise that resolves when the API is initialised.
+ * @throws {Error} If API initialisation fails.
+ * @example
+ * await initialiseGMapsNoContext({ key: 'YOUR_API_KEY', v: 'weekly' });
  */
 export function initialiseGMapsNoContext(options) {
     return new Promise((resolve, reject) => {
@@ -83,5 +117,10 @@ export function initialiseGMapsNoContext(options) {
         }
     });
 }
-// Re-export importLibrary for components to use.
+/**
+ * Re-exported from @googlemaps/js-api-loader for convenient access.
+ * Dynamically imports a specific Google Maps library (e.g., 'places', 'maps', 'marker').
+ * @public
+ * @see https://developers.google.com/maps/documentation/javascript/importing-libraries
+ */
 export { importLibrary };

package/dist/helpers.js

@@ -290,30 +290,33 @@ export const validateFetchFields = (fetchFields) => {
  * Default component classes
  */
 export const componentClasses = {
-    section: '',
-    container: 'relative z-10 transform rounded-xl mt-4',
-    icon_container: 'pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3',
-    icon: '<svg xmlns="http://www.w3.org/2000/svg" class="w-5 h-5" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8" /><path d="m21 21-4.3-4.3" /></svg>',
-    input: 'border-1 w-full rounded-md border-0 shadow-sm bg-gray-100 px-4 py-2.5 pl-10 pr-20 text-gray-900 ring-1 ring-inset ring-gray-300 focus:ring-2 sm:text-sm',
-    kbd_container: 'absolute inset-y-0 right-0 flex py-1.5 pr-1.5',
-    kbd_escape: 'inline-flex items-center rounded border border-gray-300 px-1 font-sans text-xs text-gray-500 w-8 mr-1',
-    kbd_up: 'inline-flex items-center justify-center rounded border border-gray-300 px-1 font-sans text-xs text-gray-500 w-6',
-    kbd_down: 'inline-flex items-center rounded border border-gray-400 px-1 font-sans text-xs text-gray-500 justify-center w-6',
-    kbd_active: 'bg-indigo-500 text-white',
-    ul: 'absolute z-50 -mb-2 mt-1 max-h-60 w-full overflow-auto rounded-md bg-white py-1 text-base shadow-lg ring-1 ring-black ring-opacity-5 focus:outline-none sm:text-sm divide-y divide-gray-100',
-    li: 'z-50 cursor-default select-none py-2 px-2 lg:px-4 text-gray-900 hover:bg-indigo-500 hover:text-white',
-    li_current: 'bg-indigo-500 text-white',
-    li_a: 'block w-full flex justify-between',
-    li_a_current: 'text-white',
-    li_div_container: 'flex min-w-0 gap-x-4',
-    li_div_one: 'min-w-0 flex-auto flex gap-x-4 justify-center items-center',
-    li_div_p_container: 'min-w-0 flex-auto',
-    li_div_one_p: 'text-sm/6 text-left',
+    section: 'pac-section',
+    container: 'pac-container', //'relative z-10 transform rounded-xl mt-4',
+    icon_container: 'pac-icon-container', //'pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3',
+    icon: '<svg xmlns="http://www.w3.org/2000/svg" style="width: 1.25rem; height: 1.25rem;" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8" /><path d="m21 21-4.3-4.3" /></svg>',
+    input: 'pac-input',
+    //'border-1 w-full rounded-md border-0 shadow-sm bg-gray-100 px-4 py-2.5 pl-10 pr-20 text-gray-900 ring-1 ring-inset ring-gray-300 focus:ring-2 sm:text-sm',
+    kbd_container: 'pac-kbd-container', //'absolute inset-y-0 right-0 flex py-1.5 pr-1.5',
+    kbd_escape: 'pac-kbd-escape', //'inline-flex items-center rounded border border-gray-300 px-1 font-sans text-xs text-gray-500 w-8 mr-1',
+    kbd_up: 'pac-kbd-up',
+    //'inline-flex items-center justify-center rounded border border-gray-300 px-1 font-sans text-xs text-gray-500 w-6',
+    kbd_down: 'pac-kbd-down',
+    //'inline-flex items-center rounded border border-gray-400 px-1 font-sans text-xs text-gray-500 justify-center w-6',
+    kbd_active: 'pac-kbd-active', //'bg-indigo-500 text-white',
+    ul: 'pac-ul', //'absolute z-50 -mb-2 mt-1 max-h-60 w-full overflow-auto rounded-md bg-white py-1 text-base shadow-lg ring-1 ring-black ring-opacity-5 focus:outline-none sm:text-sm divide-y divide-gray-100',
+    li: 'pac-li', //'z-50 cursor-default select-none py-2 px-2 lg:px-4 text-gray-900 hover:bg-indigo-500 hover:text-white',
+    li_current: 'pac-li-current', //'bg-indigo-500 text-white',
+    li_button: 'pac-li-button', //'block w-full flex justify-between',
+    li_button_current: 'pac-li-button-current', //'text-white',
+    li_div_container: 'pac-li-div-container', //'flex min-w-0 gap-x-4',
+    li_div_one: 'pac-li-div-one', //'min-w-0 flex-auto flex gap-x-4 justify-center items-center',
+    li_div_p_container: 'pac-li-div-p-container', //'min-w-0 flex-auto',
+    li_div_one_p: 'pac-li-div-one-p', //'text-sm/6 text-left',
+    li_div_one_p_secondaryText: 'pac-li-div-one-p-secondaryText', //'text-xs text-left leading-2',
+    li_div_two: 'pac-li-div-two', //'shrink-0 flex flex-col items-end min-w-16',
+    li_div_two_p: 'pac-li-div-two-p', //'mt-1 text-xs/5',
+    highlight: 'pac-highlight', //'font-bold',
     map_pin_icon: '<path d="M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"/><circle cx="12" cy="10" r="3"/>',
-    li_div_one_p_secondaryText: 'text-xs text-left leading-2',
-    li_div_two: 'shrink-0 flex flex-col items-end min-w-16',
-    li_div_two_p: 'mt-1 text-xs/5',
-    highlight: 'font-bold',
 };
 /**
  * Default component options

package/dist/interfaces.d.ts

@@ -1,73 +1,179 @@
 /**
+ * Configuration parameters for Google Places Autocomplete API requests.
  * @interface RequestParams
- * https://developers.google.com/maps/documentation/javascript/reference/autocomplete-data
+ * @see https://developers.google.com/maps/documentation/javascript/reference/autocomplete-data
  */
 export interface RequestParams {
+    /** The user's search input string. Automatically managed by the component. */
     input?: string;
+    /** Array of place types to include in results (e.g., ['restaurant', 'cafe']). */
     includedPrimaryTypes?: string[];
+    /** Array of region codes (CLDR format) to restrict results (e.g., ['US', 'CA']). */
     includedRegionCodes?: string[];
+    /** Zero-based character position in the input string where the service should start matching. */
     inputOffset?: number;
+    /** Language code for search results (e.g., 'en', 'fr', 'es'). */
     language?: string;
+    /**
+     * Location bias to prefer results near a specific location.
+     * Accepts LatLng, LatLngLiteral, LatLngBounds, LatLngBoundsLiteral, Circle, CircleLiteral, or string.
+     */
     locationBias?: {
         lat: number;
         lng: number;
     };
+    /**
+     * Location restriction to return only results within a specific area.
+     * Defines a rectangular boundary using geographic coordinates.
+     */
     locationRestriction?: {
         west: number;
         south: number;
         east: number;
         north: number;
     };
+    /**
+     * Origin point for calculating distance in results.
+     * Accepts LatLng or LatLngLiteral.
+     */
     origin?: {
         lat: number;
         lng: number;
     };
+    /** IANA region code (e.g., 'us', 'gb') to bias results. */
     region?: string;
+    /** Autocomplete session token for billing optimization. Automatically managed by the component. */
     sessionToken?: string;
 }
+/**
+ * CSS class names for styling component elements.
+ * Map of component element identifiers to custom CSS class strings.
+ * @interface ComponentClasses
+ * @example
+ * {
+ *   input: 'my-custom-input',
+ *   ul: 'my-dropdown-list',
+ *   li: 'my-list-item'
+ * }
+ */
 export interface ComponentClasses {
     [key: string]: string;
 }
+/**
+ * HTML autocomplete attribute values.
+ * Controls browser autofill behavior for the input field.
+ * @type {"on" | "off"}
+ */
 export type AutoFill = "on" | "off";
+/**
+ * Distance measurement units for displaying place distances.
+ * @type {"km" | "miles"}
+ */
 export type DistanceUnits = "km" | "miles";
+/**
+ * Configuration options for customizing the PlaceAutocomplete component behavior and appearance.
+ * @interface ComponentOptions
+ */
 export interface ComponentOptions {
+    /** Automatically focus the input field when the component mounts. @default false */
     autofocus?: boolean;
+    /** Browser autocomplete/autofill behavior for the input field. @default "off" */
     autocomplete?: AutoFill;
+    /** Custom CSS classes for component elements (input, ul, li, etc.). */
     classes?: ComponentClasses;
+    /** Placeholder text displayed in the input field. @default "Search for a place..." */
     placeholder?: string;
+    /** Display distance from origin in autocomplete suggestions. @default false */
     distance?: boolean;
+    /** Unit of measurement for distance display. @default "km" */
     distance_units?: DistanceUnits;
+    /** Label text displayed above the input field. */
     label?: string;
+    /** Debounce delay in milliseconds for API requests. @default 100 */
     debounce?: number;
+    /** Clear the input field after selecting a place. @default true */
     clear_input?: boolean;
 }
+/**
+ * Detailed information about a selected place returned by the Google Places API.
+ * Contains formatted address, address components, location coordinates, and additional place data
+ * depending on the requested fetch fields.
+ * @interface PlaceResult
+ * @see https://developers.google.com/maps/documentation/javascript/place-data-fields
+ */
 export interface PlaceResult {
+    /** Human-readable address of the place (e.g., "1600 Amphitheatre Parkway, Mountain View, CA"). */
     formattedAddress: string;
+    /**
+     * Array of address components (street, city, state, country, postal code, etc.).
+     * Each component includes long text, short text, and type identifiers.
+     */
     addressComponents: {
+        /** Full text representation of the address component (e.g., "California"). */
         longText: string;
+        /** Abbreviated representation of the address component (e.g., "CA"). */
         shortText: string;
+        /** Array of types describing the component (e.g., ["administrative_area_level_1", "political"]). */
         types: string[];
     }[];
+    /** Geographic coordinates (latitude and longitude) of the place. */
     location?: {
         lat: number;
         lng: number;
     };
+    /** Additional place data fields as requested via fetchFields prop (e.g., displayName, types, photos). */
     [key: string]: unknown;
 }
+/**
+ * Standardized address format with commonly used components extracted from PlaceResult.
+ * Provides a consistent structure for address data across different regions.
+ * @interface FormattedAddress
+ */
 export interface FormattedAddress {
+    /** Street number (e.g., "1600"). */
     street_number: string;
+    /** Street name (e.g., "Amphitheatre Parkway"). */
     street: string;
+    /** City or locality name (e.g., "Mountain View"). */
     town: string;
+    /** County or administrative area (e.g., "Santa Clara County"). */
     county: string;
+    /** Two-letter ISO country code (e.g., "US", "GB", "FR"). */
     country_iso2: string;
+    /** Postal/ZIP code (e.g., "94043"). */
     postcode: string;
 }
+/**
+ * Component props for the PlaceAutocomplete Svelte component.
+ * @interface Props
+ */
 export interface Props {
+    /**
+     * Google Maps API key for Places API authentication.
+     * Required if not using a parent GMapsProvider component.
+     * @see https://developers.google.com/maps/documentation/javascript/get-api-key
+     */
     PUBLIC_GOOGLE_MAPS_API_KEY?: string;
+    /** Configuration options for component behavior and styling. */
     options?: ComponentOptions;
+    /**
+     * Array of Place Data Fields to fetch when a place is selected.
+     * @default ['addressComponents', 'formattedAddress']
+     * @see https://developers.google.com/maps/documentation/javascript/place-data-fields
+     */
     fetchFields?: string[];
+    /** Google Maps libraries to load (managed internally, reserved for future use). */
     libraries?: string[];
+    /** Additional parameters for Places Autocomplete API requests. */
     requestParams?: RequestParams;
+    /**
+     * Callback function invoked when a place is successfully selected.
+     * Receives the complete PlaceResult object with requested fields.
+     */
     onResponse: (response: PlaceResult) => void;
+    /**
+     * Callback function invoked when an error occurs during API calls.
+     * Receives an error message string describing the issue.
+     */
     onError: (error: string) => void;
 }

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "places-autocomplete-svelte",
 	"license": "MIT",
-	"version": "2.2.20",
-	"description": "A flexible, accessible, and secure Svelte component leveraging the Google Maps Places Autocomplete API (New) to provide a user-friendly way to search for and retrieve detailed address information.",
+	"version": "2.2.22",
+	"description": "A flexible, accessible, and secure Svelte component leveraging the Google Maps Places Autocomplete API (New). Winner of the Google Maps Platform Awards 2025, recognising excellence in Google Maps Platform development.",
 	"keywords": [
 		"svelte",
 		"sveltekit",
@@ -17,7 +17,7 @@
 		"input",
 		"search"
 	],
-	"homepage": "https://places-autocomplete-demo.pages.dev",
+	"homepage": "https://places-autocomplete-svelte.uk",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/alexpechkarev/places-autocomplete-svelte.git"
@@ -77,31 +77,31 @@
 	"devDependencies": {
 		"@sveltejs/adapter-auto": "^7.0.0",
 		"@sveltejs/adapter-cloudflare": "^7.2.4",
-		"@sveltejs/kit": "^2.49.1",
+		"@sveltejs/kit": "^2.49.2",
 		"@sveltejs/package": "^2.5.7",
 		"@sveltejs/vite-plugin-svelte": "^6.2.1",
-		"@tailwindcss/postcss": "^4.1.17",
+		"@tailwindcss/postcss": "^4.1.18",
 		"@tailwindcss/typography": "^0.5.19",
-		"@tailwindcss/vite": "^4.1.17",
+		"@tailwindcss/vite": "^4.1.18",
 		"@types/eslint": "^9.6.1",
 		"@types/google.maps": "^3.58.1",
-		"@types/node": "^24.10.1",
-		"autoprefixer": "^10.4.22",
-		"eslint": "^9.39.1",
+		"@types/node": "^25.0.3",
+		"autoprefixer": "^10.4.23",
+		"eslint": "^9.39.2",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-svelte": "^3.13.1",
-		"globals": "^16.5.0",
+		"globals": "^17.0.0",
 		"postcss": "^8.5.6",
 		"prettier": "^3.7.4",
-		"prettier-plugin-svelte": "^3.4.0",
-		"publint": "^0.3.15",
-		"svelte": "^5.45.6",
-		"svelte-check": "^4.3.4",
-		"tailwindcss": "^4.1.17",
+		"prettier-plugin-svelte": "^3.4.1",
+		"publint": "^0.3.16",
+		"svelte": "^5.46.1",
+		"svelte-check": "^4.3.5",
+		"tailwindcss": "^4.1.18",
 		"tslib": "^2.8.1",
 		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.48.1",
-		"vite": "^7.2.6"
+		"typescript-eslint": "^8.51.0",
+		"vite": "^7.3.0"
 	},
 	"svelte": "./dist/index.js",
 	"types": "./dist/PlaceAutocomplete.svelte.d.ts",