/** * @license AngularJS v1.8.2 * (c) 2010-2020 Google LLC. http://angularjs.org * License: MIT */ (function(window, angular) {'use strict'; /* global shallowCopy: true */ /** * Creates a shallow copy of an object, an array or a primitive. * * Assumes that there are no proto properties for objects. */ function shallowCopy(src, dst) { if (isArray(src)) { dst = dst || []; for (var i = 0, ii = src.length; i < ii; i++) { dst[i] = src[i]; } } else if (isObject(src)) { dst = dst || {}; for (var key in src) { if (!(key.charAt(0) === '$' && key.charAt(1) === '$')) { dst[key] = src[key]; } } } return dst || src; } /* global routeToRegExp: true */ /** * @param {string} path - The path to parse. (It is assumed to have query and hash stripped off.) * @param {Object} opts - Options. * @return {Object} - An object containing an array of path parameter names (`keys`) and a regular * expression (`regexp`) that can be used to identify a matching URL and extract the path * parameter values. * * @description * Parses the given path, extracting path parameter names and a regular expression to match URLs. * * Originally inspired by `pathRexp` in `visionmedia/express/lib/utils.js`. */ function routeToRegExp(path, opts) { var keys = []; var pattern = path .replace(/([().])/g, '\\$1') .replace(/(\/)?:(\w+)(\*\?|[?*])?/g, function(_, slash, key, option) { var optional = option === '?' || option === '*?'; var star = option === '*' || option === '*?'; keys.push({name: key, optional: optional}); slash = slash || ''; return ( (optional ? '(?:' + slash : slash + '(?:') + (star ? '(.+?)' : '([^/]+)') + (optional ? '?)?' : ')') ); }) .replace(/([/$*])/g, '\\$1'); if (opts.ignoreTrailingSlashes) { pattern = pattern.replace(/\/+$/, '') + '/*'; } return { keys: keys, regexp: new RegExp( '^' + pattern + '(?:[?#]|$)', opts.caseInsensitiveMatch ? 'i' : '' ) }; } /* global routeToRegExp: false */ /* global shallowCopy: false */ // `isArray` and `isObject` are necessary for `shallowCopy()` (included via `src/shallowCopy.js`). // They are initialized inside the `$RouteProvider`, to ensure `window.angular` is available. var isArray; var isObject; var isDefined; var noop; /** * @ngdoc module * @name ngRoute * @description * * The `ngRoute` module provides routing and deeplinking services and directives for AngularJS apps. * * ## Example * See {@link ngRoute.$route#examples $route} for an example of configuring and using `ngRoute`. * */ /* global -ngRouteModule */ var ngRouteModule = angular. module('ngRoute', []). info({ angularVersion: '1.8.2' }). provider('$route', $RouteProvider). // Ensure `$route` will be instantiated in time to capture the initial `$locationChangeSuccess` // event (unless explicitly disabled). This is necessary in case `ngView` is included in an // asynchronously loaded template. run(instantiateRoute); var $routeMinErr = angular.$$minErr('ngRoute'); var isEagerInstantiationEnabled; /** * @ngdoc provider * @name $routeProvider * @this * * @description * * Used for configuring routes. * * ## Example * See {@link ngRoute.$route#examples $route} for an example of configuring and using `ngRoute`. * * ## Dependencies * Requires the {@link ngRoute `ngRoute`} module to be installed. */ function $RouteProvider() { isArray = angular.isArray; isObject = angular.isObject; isDefined = angular.isDefined; noop = angular.noop; function inherit(parent, extra) { return angular.extend(Object.create(parent), extra); } var routes = {}; /** * @ngdoc method * @name $routeProvider#when * * @param {string} path Route path (matched against `$location.path`). If `$location.path` * contains redundant trailing slash or is missing one, the route will still match and the * `$location.path` will be updated to add or drop the trailing slash to exactly match the * route definition. * * * `path` can contain named groups starting with a colon: e.g. `:name`. All characters up * to the next slash are matched and stored in `$routeParams` under the given `name` * when the route matches. * * `path` can contain named groups starting with a colon and ending with a star: * e.g.`:name*`. All characters are eagerly stored in `$routeParams` under the given `name` * when the route matches. * * `path` can contain optional named groups with a question mark: e.g.`:name?`. * * For example, routes like `/color/:color/largecode/:largecode*\/edit` will match * `/color/brown/largecode/code/with/slashes/edit` and extract: * * * `color: brown` * * `largecode: code/with/slashes`. * * * @param {Object} route Mapping information to be assigned to `$route.current` on route * match. * * Object properties: * * - `controller` – `{(string|Function)=}` – Controller fn that should be associated with * newly created scope or the name of a {@link angular.Module#controller registered * controller} if passed as a string. * - `controllerAs` – `{string=}` – An identifier name for a reference to the controller. * If present, the controller will be published to scope under the `controllerAs` name. * - `template` – `{(string|Function)=}` – html template as a string or a function that * returns an html template as a string which should be used by {@link * ngRoute.directive:ngView ngView} or {@link ng.directive:ngInclude ngInclude} directives. * This property takes precedence over `templateUrl`. * * If `template` is a function, it will be called with the following parameters: * * - `{Array.}` - route parameters extracted from the current * `$location.path()` by applying the current route * * One of `template` or `templateUrl` is required. * * - `templateUrl` – `{(string|Function)=}` – path or function that returns a path to an html * template that should be used by {@link ngRoute.directive:ngView ngView}. * * If `templateUrl` is a function, it will be called with the following parameters: * * - `{Array.}` - route parameters extracted from the current * `$location.path()` by applying the current route * * One of `templateUrl` or `template` is required. * * - `resolve` - `{Object.=}` - An optional map of dependencies which should * be injected into the controller. If any of these dependencies are promises, the router * will wait for them all to be resolved or one to be rejected before the controller is * instantiated. * If all the promises are resolved successfully, the values of the resolved promises are * injected and {@link ngRoute.$route#$routeChangeSuccess $routeChangeSuccess} event is * fired. If any of the promises are rejected the * {@link ngRoute.$route#$routeChangeError $routeChangeError} event is fired. * For easier access to the resolved dependencies from the template, the `resolve` map will * be available on the scope of the route, under `$resolve` (by default) or a custom name * specified by the `resolveAs` property (see below). This can be particularly useful, when * working with {@link angular.Module#component components} as route templates.
*
* **Note:** If your scope already contains a property with this name, it will be hidden * or overwritten. Make sure, you specify an appropriate name for this property, that * does not collide with other properties on the scope. *
* The map object is: * * - `key` – `{string}`: a name of a dependency to be injected into the controller. * - `factory` - `{string|Function}`: If `string` then it is an alias for a service. * Otherwise if function, then it is {@link auto.$injector#invoke injected} * and the return value is treated as the dependency. If the result is a promise, it is * resolved before its value is injected into the controller. Be aware that * `ngRoute.$routeParams` will still refer to the previous route within these resolve * functions. Use `$route.current.params` to access the new route parameters, instead. * * - `resolveAs` - `{string=}` - The name under which the `resolve` map will be available on * the scope of the route. If omitted, defaults to `$resolve`. * * - `redirectTo` – `{(string|Function)=}` – value to update * {@link ng.$location $location} path with and trigger route redirection. * * If `redirectTo` is a function, it will be called with the following parameters: * * - `{Object.}` - route parameters extracted from the current * `$location.path()` by applying the current route templateUrl. * - `{string}` - current `$location.path()` * - `{Object}` - current `$location.search()` * * The custom `redirectTo` function is expected to return a string which will be used * to update `$location.url()`. If the function throws an error, no further processing will * take place and the {@link ngRoute.$route#$routeChangeError $routeChangeError} event will * be fired. * * Routes that specify `redirectTo` will not have their controllers, template functions * or resolves called, the `$location` will be changed to the redirect url and route * processing will stop. The exception to this is if the `redirectTo` is a function that * returns `undefined`. In this case the route transition occurs as though there was no * redirection. * * - `resolveRedirectTo` – `{Function=}` – a function that will (eventually) return the value * to update {@link ng.$location $location} URL with and trigger route redirection. In * contrast to `redirectTo`, dependencies can be injected into `resolveRedirectTo` and the * return value can be either a string or a promise that will be resolved to a string. * * Similar to `redirectTo`, if the return value is `undefined` (or a promise that gets * resolved to `undefined`), no redirection takes place and the route transition occurs as * though there was no redirection. * * If the function throws an error or the returned promise gets rejected, no further * processing will take place and the * {@link ngRoute.$route#$routeChangeError $routeChangeError} event will be fired. * * `redirectTo` takes precedence over `resolveRedirectTo`, so specifying both on the same * route definition, will cause the latter to be ignored. * * - `[reloadOnUrl=true]` - `{boolean=}` - reload route when any part of the URL changes * (including the path) even if the new URL maps to the same route. * * If the option is set to `false` and the URL in the browser changes, but the new URL maps * to the same route, then a `$routeUpdate` event is broadcasted on the root scope (without * reloading the route). * * - `[reloadOnSearch=true]` - `{boolean=}` - reload route when only `$location.search()` * or `$location.hash()` changes. * * If the option is set to `false` and the URL in the browser changes, then a `$routeUpdate` * event is broadcasted on the root scope (without reloading the route). * *
* **Note:** This option has no effect if `reloadOnUrl` is set to `false`. *
* * - `[caseInsensitiveMatch=false]` - `{boolean=}` - match routes without being case sensitive * * If the option is set to `true`, then the particular route can be matched without being * case sensitive * * @returns {Object} self * * @description * Adds a new route definition to the `$route` service. */ this.when = function(path, route) { //copy original route object to preserve params inherited from proto chain var routeCopy = shallowCopy(route); if (angular.isUndefined(routeCopy.reloadOnUrl)) { routeCopy.reloadOnUrl = true; } if (angular.isUndefined(routeCopy.reloadOnSearch)) { routeCopy.reloadOnSearch = true; } if (angular.isUndefined(routeCopy.caseInsensitiveMatch)) { routeCopy.caseInsensitiveMatch = this.caseInsensitiveMatch; } routes[path] = angular.extend( routeCopy, {originalPath: path}, path && routeToRegExp(path, routeCopy) ); // create redirection for trailing slashes if (path) { var redirectPath = (path[path.length - 1] === '/') ? path.substr(0, path.length - 1) : path + '/'; routes[redirectPath] = angular.extend( {originalPath: path, redirectTo: path}, routeToRegExp(redirectPath, routeCopy) ); } return this; }; /** * @ngdoc property * @name $routeProvider#caseInsensitiveMatch * @description * * A boolean property indicating if routes defined * using this provider should be matched using a case insensitive * algorithm. Defaults to `false`. */ this.caseInsensitiveMatch = false; /** * @ngdoc method * @name $routeProvider#otherwise * * @description * Sets route definition that will be used on route change when no other route definition * is matched. * * @param {Object|string} params Mapping information to be assigned to `$route.current`. * If called with a string, the value maps to `redirectTo`. * @returns {Object} self */ this.otherwise = function(params) { if (typeof params === 'string') { params = {redirectTo: params}; } this.when(null, params); return this; }; /** * @ngdoc method * @name $routeProvider#eagerInstantiationEnabled * @kind function * * @description * Call this method as a setter to enable/disable eager instantiation of the * {@link ngRoute.$route $route} service upon application bootstrap. You can also call it as a * getter (i.e. without any arguments) to get the current value of the * `eagerInstantiationEnabled` flag. * * Instantiating `$route` early is necessary for capturing the initial * {@link ng.$location#$locationChangeStart $locationChangeStart} event and navigating to the * appropriate route. Usually, `$route` is instantiated in time by the * {@link ngRoute.ngView ngView} directive. Yet, in cases where `ngView` is included in an * asynchronously loaded template (e.g. in another directive's template), the directive factory * might not be called soon enough for `$route` to be instantiated _before_ the initial * `$locationChangeSuccess` event is fired. Eager instantiation ensures that `$route` is always * instantiated in time, regardless of when `ngView` will be loaded. * * The default value is true. * * **Note**:
* You may want to disable the default behavior when unit-testing modules that depend on * `ngRoute`, in order to avoid an unexpected request for the default route's template. * * @param {boolean=} enabled - If provided, update the internal `eagerInstantiationEnabled` flag. * * @returns {*} The current value of the `eagerInstantiationEnabled` flag if used as a getter or * itself (for chaining) if used as a setter. */ isEagerInstantiationEnabled = true; this.eagerInstantiationEnabled = function eagerInstantiationEnabled(enabled) { if (isDefined(enabled)) { isEagerInstantiationEnabled = enabled; return this; } return isEagerInstantiationEnabled; }; this.$get = ['$rootScope', '$location', '$routeParams', '$q', '$injector', '$templateRequest', '$sce', '$browser', function($rootScope, $location, $routeParams, $q, $injector, $templateRequest, $sce, $browser) { /** * @ngdoc service * @name $route * @requires $location * @requires $routeParams * * @property {Object} current Reference to the current route definition. * The route definition contains: * * - `controller`: The controller constructor as defined in the route definition. * - `locals`: A map of locals which is used by {@link ng.$controller $controller} service for * controller instantiation. The `locals` contain * the resolved values of the `resolve` map. Additionally the `locals` also contain: * * - `$scope` - The current route scope. * - `$template` - The current route template HTML. * * The `locals` will be assigned to the route scope's `$resolve` property. You can override * the property name, using `resolveAs` in the route definition. See * {@link ngRoute.$routeProvider $routeProvider} for more info. * * @property {Object} routes Object with all route configuration Objects as its properties. * * @description * `$route` is used for deep-linking URLs to controllers and views (HTML partials). * It watches `$location.url()` and tries to map the path to an existing route definition. * * Requires the {@link ngRoute `ngRoute`} module to be installed. * * You can define routes through {@link ngRoute.$routeProvider $routeProvider}'s API. * * The `$route` service is typically used in conjunction with the * {@link ngRoute.directive:ngView `ngView`} directive and the * {@link ngRoute.$routeParams `$routeParams`} service. * * @example * This example shows how changing the URL hash causes the `$route` to match a route against the * URL, and the `ngView` pulls in the partial. * * * *
* Choose: * Moby | * Moby: Ch1 | * Gatsby | * Gatsby: Ch4 | * Scarlet Letter
* *
* *
* * 
$location.path() = {{$location.path()}}
* 
$route.current.templateUrl = {{$route.current.templateUrl}}
* 
$route.current.params = {{$route.current.params}}
* 
$route.current.scope.name = {{$route.current.scope.name}}
* 
$routeParams = {{$routeParams}}
*
* * * * controller: {{name}}
* Book Id: {{params.bookId}}
* * * * controller: {{name}}
* Book Id: {{params.bookId}}
* Chapter Id: {{params.chapterId}} * * * * angular.module('ngRouteExample', ['ngRoute']) * * .controller('MainController', function($scope, $route, $routeParams, $location) { * $scope.$route = $route; * $scope.$location = $location; * $scope.$routeParams = $routeParams; * }) * * .controller('BookController', function($scope, $routeParams) { * $scope.name = 'BookController'; * $scope.params = $routeParams; * }) * * .controller('ChapterController', function($scope, $routeParams) { * $scope.name = 'ChapterController'; * $scope.params = $routeParams; * }) * * .config(function($routeProvider, $locationProvider) { * $routeProvider * .when('/Book/:bookId', { * templateUrl: 'book.html', * controller: 'BookController', * resolve: { * // I will cause a 1 second delay * delay: function($q, $timeout) { * var delay = $q.defer(); * $timeout(delay.resolve, 1000); * return delay.promise; * } * } * }) * .when('/Book/:bookId/ch/:chapterId', { * templateUrl: 'chapter.html', * controller: 'ChapterController' * }); * * // configure html5 to get links working on jsfiddle * $locationProvider.html5Mode(true); * }); * * * * * it('should load and compile correct template', function() { * element(by.linkText('Moby: Ch1')).click(); * var content = element(by.css('[ng-view]')).getText(); * expect(content).toMatch(/controller: ChapterController/); * expect(content).toMatch(/Book Id: Moby/); * expect(content).toMatch(/Chapter Id: 1/); * * element(by.partialLinkText('Scarlet')).click(); * * content = element(by.css('[ng-view]')).getText(); * expect(content).toMatch(/controller: BookController/); * expect(content).toMatch(/Book Id: Scarlet/); * }); * * */ /** * @ngdoc event * @name $route#$routeChangeStart * @eventType broadcast on root scope * @description * Broadcasted before a route change. At this point the route services starts * resolving all of the dependencies needed for the route change to occur. * Typically this involves fetching the view template as well as any dependencies * defined in `resolve` route property. Once all of the dependencies are resolved * `$routeChangeSuccess` is fired. * * The route change (and the `$location` change that triggered it) can be prevented * by calling `preventDefault` method of the event. See {@link ng.$rootScope.Scope#$on} * for more details about event object. * * @param {Object} angularEvent Synthetic event object. * @param {Route} next Future route information. * @param {Route} current Current route information. */ /** * @ngdoc event * @name $route#$routeChangeSuccess * @eventType broadcast on root scope * @description * Broadcasted after a route change has happened successfully. * The `resolve` dependencies are now available in the `current.locals` property. * * {@link ngRoute.directive:ngView ngView} listens for the directive * to instantiate the controller and render the view. * * @param {Object} angularEvent Synthetic event object. * @param {Route} current Current route information. * @param {Route|Undefined} previous Previous route information, or undefined if current is * first route entered. */ /** * @ngdoc event * @name $route#$routeChangeError * @eventType broadcast on root scope * @description * Broadcasted if a redirection function fails or any redirection or resolve promises are * rejected. * * @param {Object} angularEvent Synthetic event object * @param {Route} current Current route information. * @param {Route} previous Previous route information. * @param {Route} rejection The thrown error or the rejection reason of the promise. Usually * the rejection reason is the error that caused the promise to get rejected. */ /** * @ngdoc event * @name $route#$routeUpdate * @eventType broadcast on root scope * @description * Broadcasted if the same instance of a route (including template, controller instance, * resolved dependencies, etc.) is being reused. This can happen if either `reloadOnSearch` or * `reloadOnUrl` has been set to `false`. * * @param {Object} angularEvent Synthetic event object * @param {Route} current Current/previous route information. */ var forceReload = false, preparedRoute, preparedRouteIsUpdateOnly, $route = { routes: routes, /** * @ngdoc method * @name $route#reload * * @description * Causes `$route` service to reload the current route even if * {@link ng.$location $location} hasn't changed. * * As a result of that, {@link ngRoute.directive:ngView ngView} * creates new scope and reinstantiates the controller. */ reload: function() { forceReload = true; var fakeLocationEvent = { defaultPrevented: false, preventDefault: function fakePreventDefault() { this.defaultPrevented = true; forceReload = false; } }; $rootScope.$evalAsync(function() { prepareRoute(fakeLocationEvent); if (!fakeLocationEvent.defaultPrevented) commitRoute(); }); }, /** * @ngdoc method * @name $route#updateParams * * @description * Causes `$route` service to update the current URL, replacing * current route parameters with those specified in `newParams`. * Provided property names that match the route's path segment * definitions will be interpolated into the location's path, while * remaining properties will be treated as query params. * * @param {!Object} newParams mapping of URL parameter names to values */ updateParams: function(newParams) { if (this.current && this.current.$$route) { newParams = angular.extend({}, this.current.params, newParams); $location.path(interpolate(this.current.$$route.originalPath, newParams)); // interpolate modifies newParams, only query params are left $location.search(newParams); } else { throw $routeMinErr('norout', 'Tried updating route with no current route'); } } }; $rootScope.$on('$locationChangeStart', prepareRoute); $rootScope.$on('$locationChangeSuccess', commitRoute); return $route; ///////////////////////////////////////////////////// /** * @param on {string} current url * @param route {Object} route regexp to match the url against * @return {?Object} * * @description * Check if the route matches the current url. * * Inspired by match in * visionmedia/express/lib/router/router.js. */ function switchRouteMatcher(on, route) { var keys = route.keys, params = {}; if (!route.regexp) return null; var m = route.regexp.exec(on); if (!m) return null; for (var i = 1, len = m.length; i < len; ++i) { var key = keys[i - 1]; var val = m[i]; if (key && val) { params[key.name] = val; } } return params; } function prepareRoute($locationEvent) { var lastRoute = $route.current; preparedRoute = parseRoute(); preparedRouteIsUpdateOnly = isNavigationUpdateOnly(preparedRoute, lastRoute); if (!preparedRouteIsUpdateOnly && (lastRoute || preparedRoute)) { if ($rootScope.$broadcast('$routeChangeStart', preparedRoute, lastRoute).defaultPrevented) { if ($locationEvent) { $locationEvent.preventDefault(); } } } } function commitRoute() { var lastRoute = $route.current; var nextRoute = preparedRoute; if (preparedRouteIsUpdateOnly) { lastRoute.params = nextRoute.params; angular.copy(lastRoute.params, $routeParams); $rootScope.$broadcast('$routeUpdate', lastRoute); } else if (nextRoute || lastRoute) { forceReload = false; $route.current = nextRoute; var nextRoutePromise = $q.resolve(nextRoute); $browser.$$incOutstandingRequestCount('$route'); nextRoutePromise. then(getRedirectionData). then(handlePossibleRedirection). then(function(keepProcessingRoute) { return keepProcessingRoute && nextRoutePromise. then(resolveLocals). then(function(locals) { // after route change if (nextRoute === $route.current) { if (nextRoute) { nextRoute.locals = locals; angular.copy(nextRoute.params, $routeParams); } $rootScope.$broadcast('$routeChangeSuccess', nextRoute, lastRoute); } }); }).catch(function(error) { if (nextRoute === $route.current) { $rootScope.$broadcast('$routeChangeError', nextRoute, lastRoute, error); } }).finally(function() { // Because `commitRoute()` is called from a `$rootScope.$evalAsync` block (see // `$locationWatch`), this `$$completeOutstandingRequest()` call will not cause // `outstandingRequestCount` to hit zero. This is important in case we are redirecting // to a new route which also requires some asynchronous work. $browser.$$completeOutstandingRequest(noop, '$route'); }); } } function getRedirectionData(route) { var data = { route: route, hasRedirection: false }; if (route) { if (route.redirectTo) { if (angular.isString(route.redirectTo)) { data.path = interpolate(route.redirectTo, route.params); data.search = route.params; data.hasRedirection = true; } else { var oldPath = $location.path(); var oldSearch = $location.search(); var newUrl = route.redirectTo(route.pathParams, oldPath, oldSearch); if (angular.isDefined(newUrl)) { data.url = newUrl; data.hasRedirection = true; } } } else if (route.resolveRedirectTo) { return $q. resolve($injector.invoke(route.resolveRedirectTo)). then(function(newUrl) { if (angular.isDefined(newUrl)) { data.url = newUrl; data.hasRedirection = true; } return data; }); } } return data; } function handlePossibleRedirection(data) { var keepProcessingRoute = true; if (data.route !== $route.current) { keepProcessingRoute = false; } else if (data.hasRedirection) { var oldUrl = $location.url(); var newUrl = data.url; if (newUrl) { $location. url(newUrl). replace(); } else { newUrl = $location. path(data.path). search(data.search). replace(). url(); } if (newUrl !== oldUrl) { // Exit out and don't process current next value, // wait for next location change from redirect keepProcessingRoute = false; } } return keepProcessingRoute; } function resolveLocals(route) { if (route) { var locals = angular.extend({}, route.resolve); angular.forEach(locals, function(value, key) { locals[key] = angular.isString(value) ? $injector.get(value) : $injector.invoke(value, null, null, key); }); var template = getTemplateFor(route); if (angular.isDefined(template)) { locals['$template'] = template; } return $q.all(locals); } } function getTemplateFor(route) { var template, templateUrl; if (angular.isDefined(template = route.template)) { if (angular.isFunction(template)) { template = template(route.params); } } else if (angular.isDefined(templateUrl = route.templateUrl)) { if (angular.isFunction(templateUrl)) { templateUrl = templateUrl(route.params); } if (angular.isDefined(templateUrl)) { route.loadedTemplateUrl = $sce.valueOf(templateUrl); template = $templateRequest(templateUrl); } } return template; } /** * @returns {Object} the current active route, by matching it against the URL */ function parseRoute() { // Match a route var params, match; angular.forEach(routes, function(route, path) { if (!match && (params = switchRouteMatcher($location.path(), route))) { match = inherit(route, { params: angular.extend({}, $location.search(), params), pathParams: params}); match.$$route = route; } }); // No route matched; fallback to "otherwise" route return match || routes[null] && inherit(routes[null], {params: {}, pathParams:{}}); } /** * @param {Object} newRoute - The new route configuration (as returned by `parseRoute()`). * @param {Object} oldRoute - The previous route configuration (as returned by `parseRoute()`). * @returns {boolean} Whether this is an "update-only" navigation, i.e. the URL maps to the same * route and it can be reused (based on the config and the type of change). */ function isNavigationUpdateOnly(newRoute, oldRoute) { // IF this is not a forced reload return !forceReload // AND both `newRoute`/`oldRoute` are defined && newRoute && oldRoute // AND they map to the same Route Definition Object && (newRoute.$$route === oldRoute.$$route) // AND `reloadOnUrl` is disabled && (!newRoute.reloadOnUrl // OR `reloadOnSearch` is disabled || (!newRoute.reloadOnSearch // AND both routes have the same path params && angular.equals(newRoute.pathParams, oldRoute.pathParams) ) ); } /** * @returns {string} interpolation of the redirect path with the parameters */ function interpolate(string, params) { var result = []; angular.forEach((string || '').split(':'), function(segment, i) { if (i === 0) { result.push(segment); } else { var segmentMatch = segment.match(/(\w+)(?:[?*])?(.*)/); var key = segmentMatch[1]; result.push(params[key]); result.push(segmentMatch[2] || ''); delete params[key]; } }); return result.join(''); } }]; } instantiateRoute.$inject = ['$injector']; function instantiateRoute($injector) { if (isEagerInstantiationEnabled) { // Instantiate `$route` $injector.get('$route'); } } ngRouteModule.provider('$routeParams', $RouteParamsProvider); /** * @ngdoc service * @name $routeParams * @requires $route * @this * * @description * The `$routeParams` service allows you to retrieve the current set of route parameters. * * Requires the {@link ngRoute `ngRoute`} module to be installed. * * The route parameters are a combination of {@link ng.$location `$location`}'s * {@link ng.$location#search `search()`} and {@link ng.$location#path `path()`}. * The `path` parameters are extracted when the {@link ngRoute.$route `$route`} path is matched. * * In case of parameter name collision, `path` params take precedence over `search` params. * * The service guarantees that the identity of the `$routeParams` object will remain unchanged * (but its properties will likely change) even when a route change occurs. * * Note that the `$routeParams` are only updated *after* a route change completes successfully. * This means that you cannot rely on `$routeParams` being correct in route resolve functions. * Instead you can use `$route.current.params` to access the new route's parameters. * * @example * ```js * // Given: * // URL: http://server.com/index.html#/Chapter/1/Section/2?search=moby * // Route: /Chapter/:chapterId/Section/:sectionId * // * // Then * $routeParams ==> {chapterId:'1', sectionId:'2', search:'moby'} * ``` */ function $RouteParamsProvider() { this.$get = function() { return {}; }; } ngRouteModule.directive('ngView', ngViewFactory); ngRouteModule.directive('ngView', ngViewFillContentFactory); /** * @ngdoc directive * @name ngView * @restrict ECA * * @description * `ngView` is a directive that complements the {@link ngRoute.$route $route} service by * including the rendered template of the current route into the main layout (`index.html`) file. * Every time the current route changes, the included view changes with it according to the * configuration of the `$route` service. * * Requires the {@link ngRoute `ngRoute`} module to be installed. * * @animations * | Animation | Occurs | * |----------------------------------|-------------------------------------| * | {@link ng.$animate#enter enter} | when the new element is inserted to the DOM | * | {@link ng.$animate#leave leave} | when the old element is removed from to the DOM | * * The enter and leave animation occur concurrently. * * @scope * @priority 400 * @param {string=} onload Expression to evaluate whenever the view updates. * * @param {string=} autoscroll Whether `ngView` should call {@link ng.$anchorScroll * $anchorScroll} to scroll the viewport after the view is updated. * * - If the attribute is not set, disable scrolling. * - If the attribute is set without value, enable scrolling. * - Otherwise enable scrolling only if the `autoscroll` attribute value evaluated * as an expression yields a truthy value. * @example
Choose: Moby | Moby: Ch1 | Gatsby | Gatsby: Ch4 | Scarlet Letter
$location.path() = {{main.$location.path()}}
$route.current.templateUrl = {{main.$route.current.templateUrl}}
$route.current.params = {{main.$route.current.params}}
$routeParams = {{main.$routeParams}}
controller: {{book.name}}
Book Id: {{book.params.bookId}}
controller: {{chapter.name}}
Book Id: {{chapter.params.bookId}}
Chapter Id: {{chapter.params.chapterId}}
.view-animate-container { position:relative; height:100px!important; background:white; border:1px solid black; height:40px; overflow:hidden; } .view-animate { padding:10px; } .view-animate.ng-enter, .view-animate.ng-leave { transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 1.5s; display:block; width:100%; border-left:1px solid black; position:absolute; top:0; left:0; right:0; bottom:0; padding:10px; } .view-animate.ng-enter { left:100%; } .view-animate.ng-enter.ng-enter-active { left:0; } .view-animate.ng-leave.ng-leave-active { left:-100%; } angular.module('ngViewExample', ['ngRoute', 'ngAnimate']) .config(['$routeProvider', '$locationProvider', function($routeProvider, $locationProvider) { $routeProvider .when('/Book/:bookId', { templateUrl: 'book.html', controller: 'BookCtrl', controllerAs: 'book' }) .when('/Book/:bookId/ch/:chapterId', { templateUrl: 'chapter.html', controller: 'ChapterCtrl', controllerAs: 'chapter' }); $locationProvider.html5Mode(true); }]) .controller('MainCtrl', ['$route', '$routeParams', '$location', function MainCtrl($route, $routeParams, $location) { this.$route = $route; this.$location = $location; this.$routeParams = $routeParams; }]) .controller('BookCtrl', ['$routeParams', function BookCtrl($routeParams) { this.name = 'BookCtrl'; this.params = $routeParams; }]) .controller('ChapterCtrl', ['$routeParams', function ChapterCtrl($routeParams) { this.name = 'ChapterCtrl'; this.params = $routeParams; }]); it('should load and compile correct template', function() { element(by.linkText('Moby: Ch1')).click(); var content = element(by.css('[ng-view]')).getText(); expect(content).toMatch(/controller: ChapterCtrl/); expect(content).toMatch(/Book Id: Moby/); expect(content).toMatch(/Chapter Id: 1/); element(by.partialLinkText('Scarlet')).click(); content = element(by.css('[ng-view]')).getText(); expect(content).toMatch(/controller: BookCtrl/); expect(content).toMatch(/Book Id: Scarlet/); }); */ /** * @ngdoc event * @name ngView#$viewContentLoaded * @eventType emit on the current ngView scope * @description * Emitted every time the ngView content is reloaded. */ ngViewFactory.$inject = ['$route', '$anchorScroll', '$animate']; function ngViewFactory($route, $anchorScroll, $animate) { return { restrict: 'ECA', terminal: true, priority: 400, transclude: 'element', link: function(scope, $element, attr, ctrl, $transclude) { var currentScope, currentElement, previousLeaveAnimation, autoScrollExp = attr.autoscroll, onloadExp = attr.onload || ''; scope.$on('$routeChangeSuccess', update); update(); function cleanupLastView() { if (previousLeaveAnimation) { $animate.cancel(previousLeaveAnimation); previousLeaveAnimation = null; } if (currentScope) { currentScope.$destroy(); currentScope = null; } if (currentElement) { previousLeaveAnimation = $animate.leave(currentElement); previousLeaveAnimation.done(function(response) { if (response !== false) previousLeaveAnimation = null; }); currentElement = null; } } function update() { var locals = $route.current && $route.current.locals, template = locals && locals.$template; if (angular.isDefined(template)) { var newScope = scope.$new(); var current = $route.current; // Note: This will also link all children of ng-view that were contained in the original // html. If that content contains controllers, ... they could pollute/change the scope. // However, using ng-view on an element with additional content does not make sense... // Note: We can't remove them in the cloneAttchFn of $transclude as that // function is called before linking the content, which would apply child // directives to non existing elements. var clone = $transclude(newScope, function(clone) { $animate.enter(clone, null, currentElement || $element).done(function onNgViewEnter(response) { if (response !== false && angular.isDefined(autoScrollExp) && (!autoScrollExp || scope.$eval(autoScrollExp))) { $anchorScroll(); } }); cleanupLastView(); }); currentElement = clone; currentScope = current.scope = newScope; currentScope.$emit('$viewContentLoaded'); currentScope.$eval(onloadExp); } else { cleanupLastView(); } } } }; } // This directive is called during the $transclude call of the first `ngView` directive. // It will replace and compile the content of the element with the loaded template. // We need this directive so that the element content is already filled when // the link function of another directive on the same element as ngView // is called. ngViewFillContentFactory.$inject = ['$compile', '$controller', '$route']; function ngViewFillContentFactory($compile, $controller, $route) { return { restrict: 'ECA', priority: -400, link: function(scope, $element) { var current = $route.current, locals = current.locals; $element.html(locals.$template); var link = $compile($element.contents()); if (current.controller) { locals.$scope = scope; var controller = $controller(current.controller, locals); if (current.controllerAs) { scope[current.controllerAs] = controller; } $element.data('$ngControllerController', controller); $element.children().data('$ngControllerController', controller); } scope[current.resolveAs || '$resolve'] = locals; link(scope); } }; } })(window, window.angular);
MONOLOG365
Jackpot Games
Bang Gacor 1000
Bang Gacor 1000
NEKO X NEKO
NEKO X NEKO
Tokyo Drift Nitro
Tokyo Drift Nitro
Mines+
Mines+
Koi Gate
Koi Gate
The Crypt
The Crypt
New Games
Fortune of Olympus
Fortune of Olympus
Roma Legacy
Roma Legacy
Hot Hot Fruit
Hot Hot Fruit
Wild Bandito
Wild Bandito
Wanted Dead Or Wild
Wanted Dead Or Wild
Wild Beans
Wild Beans
Game Populer
Mahjong Wins 2
Mahjong Wins 2
Fortune Monkey
Fortune Monkey
The Great Icescape
The Great Icescape
Wukong Black Scatter
Wukong Black Scatter
Crypto Mania
Crypto Mania
Trump Card
Trump Card

Casinos That Accept Google Pay UK 2026: Verified List & Expert Guide

Google Pay has been around for years, but only recently did UK casino players start treating it as a serious banking option. The reason is simple: nobody enjoys typing 16-digit card numbers into a website that also asks for your mother’s maiden name. Google Pay removes that step. It works through your phone or browser, using a tokenised version of your debit card. In 2026, the list of UK online casinos that accept Google Pay deposits has grown beyond the usual suspects, and it now includes a mix of old-school bookmakers and mobile-first casino brands. This guide is built for players who want the convenience without sacrificing safety. We have checked the licensing, tested the cashier pages where possible, and separated the operators that actually process Google Pay from those that merely mention it in a FAQ.

How Google Pay Works at UK Online Casinos

Google Pay is not a bank account. It is a digital wallet that stores a tokenised copy of your debit card. When you deposit at a casino that supports Google Pay, you choose Google Pay as the payment method, confirm the amount, and authenticate the transaction with your fingerprint, face, or PIN. The casino receives a one-time token, not your card number. The actual money moves from your linked card to the casino’s merchant account via the card networks. That means a Google Pay deposit is processed like a card purchase, not a bank transfer or e-wallet transfer.

UK casinos have been slow to adopt Google Pay compared with Apple Pay. Apple Pay got the early push because iPhone users tend to spend more on mobile apps. But Android’s market share in the UK is significant, and operators have noticed. By 2026, most major UKGC-licensed casinos have added Google Pay as a deposit option, although a few still hide it behind the ‘mobile payment’ tab. On desktop, Google Pay works through Chrome if you have a Google account and a saved payment method. You might have to scan a QR code with your phone to confirm.

One thing to understand: Google Pay does not work as a standalone payment method at casinos that have not integrated it. You cannot just enter a Google Pay email or phone number. The casino’s cashier must list Google Pay as an option. If you do not see it, the operator has not enabled it. That is not a scam, just a business decision. Some casinos prefer to push their own branded wallets or direct bank transfers because those have lower processing costs.

Top Casinos Accepting Google Pay in the UK

Below is a verified list of UKGC-licensed casinos that currently accept Google Pay for deposits. We have focused on operators with a long track record, transparent terms, and a real UK presence. The bonus column shows the type of welcome offer you can expect, not a guaranteed amount, because promotions change almost monthly. Always check the cashier and T&Cs before depositing.

Casino / Operator Bonus Type UK Licence Min Deposit Payout Speed
Bet365 Casino Welcome package UKGC £5 1-3 days
William Hill Casino Deposit match + free spins UKGC £10 1-2 days
888casino Welcome bonus + free spins UKGC £10 1-3 days
LeoVegas Deposit match + free spins UKGC £10 1-2 days
Casumo Welcome bonus UKGC £10 1-2 days
Mr Green Deposit match + free spins UKGC £10 1-3 days
Betway Casino Welcome package UKGC £10 1-3 days
Grosvenor Casinos Welcome bonus UKGC £10 1-2 days
Paddy Power Casino Deposit match + free spins UKGC £10 1-2 days
Coral Casino Welcome bonus UKGC £10 1-2 days

The list is not exhaustive, but these are the operators most often mentioned by UK players looking for Google Pay deposits. Bet365 remains the default choice for players who want a single account for sports betting and casino. William Hill and Coral have deep high-street roots, which some players find reassuring. LeoVegas and Casumo are mobile-first brands that treat Google Pay as a native feature rather than an afterthought. 888casino and Mr Green are solid mid-tier options with strong game libraries and decent payout speeds. If you want to play at a land-based casino’s online arm, Grosvenor is the obvious pick.

One caveat: availability can change. Operators occasionally remove Google Pay if their payment gateway updates its terms. We recommend checking the cashier page before you register. If Google Pay is not listed, contact support and ask; sometimes it is available only on the mobile app, not the desktop site.

nominimumdeposit-casinos-uk.com

Is Google Pay Safe for Casino Deposits?

Short answer: yes, often safer than typing card details directly. Google Pay uses tokenisation. The casino never sees your real card number, expiry, or CVV. You authenticate each transaction with biometrics or a PIN on your device. If a casino’s database is breached, the token is useless to criminals. That is a meaningful advantage because online casinos have been targeted by data thieves in the past.

Google Pay also benefits from Google’s own fraud monitoring. If your Google account is compromised, you can revoke access from any device. And because the underlying payment method is a debit card, you are still protected by your bank’s chargeback rights, although gambling transactions are treated differently from retail purchases in practice. In the UK, gambling debt is not legally enforceable, but chargebacks against casinos are rare because the casino provided the service. Still, the tokenisation layer is a real security upgrade.

That does not mean Google Pay makes a dodgy casino safe. The security of your deposit is not the same as the fairness of the games or the operator’s licensing. Always play at UKGC-licensed casinos. Google Pay is just a payment rail; it will happily process a deposit to an unlicensed offshore site if that site manages to integrate it. The consumer protection comes from the licence, not from the wallet.

Google Pay vs Debit Cards: Which Should You Use?

If your casino accepts both Google Pay and direct debit card deposits, which should you pick? For most players, Google Pay wins on convenience and security. You do not need to find your card, type numbers, or save card details on the casino site. On mobile, it is two taps. On desktop, it is a QR scan. The downside is that Google Pay sometimes has a slightly lower deposit limit than a direct card, because Google imposes transaction caps for some users. Check your Google Pay settings.

Method Fees Deposit Time Withdrawal Support Security
Google Pay None from Google Instant No Tokenised card
Debit Card None Instant Yes, to same card Card number stored by casino
PayPal Sometimes small fee Instant Yes Wallet login
Skrill/Neteller Usually 1-2% Instant Yes Wallet login
Bank Transfer None 1-3 days Yes Bank-grade
Trustly None Instant Sometimes Bank login

The table makes the trade-off clear: Google Pay is deposit-only but extremely quick and secure. If you also want the option to withdraw to the same method, a direct debit card or an e-wallet like PayPal still has an edge. But for funding your account on a Friday night, Google Pay is hard to beat.

Casinos That Accept Klarna UK 2026: The Real Story and the Best Alternatives

Minimum Deposits and Fees with Google Pay

Google Pay does not charge a fee for casino deposits. The casino you play at may have its own minimum deposit, usually between £5 and £10. Google Pay itself does not raise that minimum. Some casinos set a higher minimum for mobile payments, but that is rare. If you see a Google Pay deposit minimum of £20, that is the casino’s policy, not Google’s.

Watch out for card issuer fees. In the UK, using a debit card through Google Pay is treated the same as using the card directly. No cash advance fee, no foreign transaction fee if you are depositing in GBP. Credit cards are banned for gambling in the UK since 2020, so you cannot link a credit card to Google Pay for casino deposits. Any casino that suggests otherwise is breaking UKGC rules.

The only potential cost is data. Google collects information about your transactions, which it uses for advertising and fraud prevention. If you are privacy-conscious, that might bother you. But for most players, the convenience outweighs the data footprint.

Can You Withdraw to Google Pay?

No. Google Pay is not a withdrawal method at any UKGC-licensed casino we have reviewed. When you request a withdrawal, the casino will send the money to the debit card you used, or to a bank account, or sometimes to an e-wallet. Google Pay does not receive funds; it only initiates them. So do not sign up expecting to cash out back to Google Pay.

Casinos That Accept Ewallets UK 2026: Top Sites, Deposits, Withdrawals

This is the single biggest limitation of Google Pay for casino players. If you deposit £50, win £200, and want to withdraw, you will need a separate withdrawal method. In practice, that means the original debit card. The process is usually automatic: the casino verifies your identity and sends the money to the same card. It can take one to three business days depending on the operator.

Some players ask if they can withdraw to Google Pay via a linked bank account. The answer is still no, because Google Pay does not operate as a receiving account for gambling winnings. If you see a casino advertising Google Pay withdrawals, treat it as a red flag. It is either mistaken or intentionally misleading.

Alternatives to Google Pay for UK Casino Players

If Google Pay is not available at your preferred casino, or you want a method that also supports withdrawals, there are solid alternatives. PayPal is the most popular e-wallet in the UK, widely accepted and reliable. Skrill and Neteller are also common, but they often carry small fees. Trustly offers instant bank transfers without creating an account. And of course, a plain debit card still works everywhere.

Apple Pay is the direct competitor to Google Pay, and many UK casinos accept both. Apple Pay works similarly: tokenised card, biometric authentication, deposit-only. If you are on iPhone, Apple Pay is often the default mobile payment. Android users get Google Pay. The casino experience is nearly identical.

For players who want to avoid any digital wallet, bank transfer is the old-school option. It is slower but has higher limits and no intermediary. Some niche methods like MuchBetter and ecoPayz also appear at UK casinos, but they are less common than they used to be. The best alternative depends on whether you need withdrawals, how fast you want to play, and what fees you will tolerate.

How to Make a Google Pay Deposit: Step-by-Step

The process is straightforward, but it varies slightly between mobile and desktop. Here is the typical flow for an Android user at a UK casino.

  1. Sign up or log in at a UKGC-licensed casino that lists Google Pay as a deposit method.
  2. Open the cashier or banking page and select ‘Deposit’.
  3. Choose Google Pay from the list of payment methods.
  4. Enter the amount you want to deposit. Ensure it meets the casino’s minimum.
  5. If you are on mobile, your Google Pay sheet will appear. Confirm the payment with your fingerprint, face, or PIN.
  6. If you are on desktop, a QR code may appear. Scan it with your phone’s Google Pay app to approve the transaction.
  7. The deposit should be credited instantly. Check your casino balance and start playing.

If the deposit fails, check that your linked debit card is active and has sufficient funds. Also ensure the card is not a credit card, as UK casinos cannot accept credit card deposits. Some Google Pay accounts have transaction limits; you can adjust them in the Google Pay settings. If the problem persists, contact casino support.

Google Pay Casino Bonuses: What to Expect

Google Pay deposits qualify for the same welcome bonuses as card deposits at most casinos. You are not treated as a second-class customer just because you used a wallet. In fact, because Google Pay is processed as a card transaction, it often falls under the same terms as a debit card deposit. That means you can claim deposit match offers, free spins, or cashback if the casino offers them.

The word ‘free’ in casino marketing deserves air quotes. Casinos are not charities. A no-deposit bonus is a customer acquisition cost, not a gift. The wagering requirements attached to Google Pay bonuses are the same as any other deposit method. Expect to wager the bonus amount 35 to 45 times before you can withdraw any winnings. Always read the T&Cs before you opt in.

A few casinos have run Google Pay-specific promotions in the past, usually small free spins for using mobile payments. These are rare and often short-lived. Do not choose a casino solely because it advertises a Google Pay bonus. The underlying licence, game selection, and withdrawal speed matter more in the long run.

Mobile Casinos and Google Pay

Google Pay is a mobile-first payment method. On an Android phone, the deposit flow is seamless. You tap deposit, choose Google Pay, confirm with your fingerprint, and you are done. No card details, no redirects to a banking app, no waiting. That is why Google Pay casinos have become popular with players who use casino apps rather than desktop sites.

On iOS, Google Pay works too, but Apple Pay is more native. Most UK casinos that accept Google Pay also accept Apple Pay, so iPhone users are not left out. On desktop, Google Pay via Chrome can be slightly clunky because you need to scan a QR code with your phone. That extra step makes desktop deposits less appealing than mobile.

One thing to note: not all casino apps support Google Pay even if the desktop site does, and vice versa. Some operators enable Google Pay only on their Android app and not on the website. If you do not see Google Pay in one environment, try the other. Or ask support before you deposit.

Legality and Licensing for UK Google Pay Casinos

Every casino listed in this guide holds a licence from the UK Gambling Commission (UKGC). That is non-negotiable for UK players. The UKGC requires operators to follow strict rules on anti-money laundering, fair games, and responsible gambling. Google Pay does not change any of that; it is just a payment rail. The licence is what protects you.

Avoid non-GamStop casinos that claim to accept Google Pay. Any UKGC-licensed casino must be part of GamStop, the national self-exclusion scheme. A site that is not on GamStop is either operating illegally in the UK or is licensed offshore with no UK consumer protection. Offshore casinos may accept Google Pay, but if something goes wrong, you have no recourse with the UKGC or UK courts.

Google Pay’s own terms of service prohibit using the wallet for illegal activities, but they do not block gambling transactions in jurisdictions where gambling is legal. However, Google Pay may restrict transactions to certain merchant categories, so some unlicensed casinos may struggle to integrate it. That is another reason to stick with UKGC operators.

New Google Pay Casinos in 2026

The UK online casino market is not growing as fast as it did in the 2010s, but new operators still launch. Many of them include Google Pay from day one because it is cheaper to integrate than building a custom wallet. In 2026, expect to see fresh UKGC-licensed casino brands with Google Pay as a standard deposit option. The challenge for players is separating the genuinely new operators from white-label clones.

We do not recommend signing up for a new casino just because it has a shiny Google Pay button. New casinos often lack a track record for withdrawals and customer support. If you want to try a new Google Pay casino, do a small deposit first, test the withdrawal process, and verify the UKGC licence number on the regulator’s website.

Casinos That Accept Interac UK 2026: Complete Guide to Deposits, Withdrawals, and Safer Alternatives

Some of the newer casino brands that accept Google Pay have been launched by existing operators as sister sites. This can be a safe bet because the operator already has infrastructure and a support team. But always check the licence, not just the brand name. A recognisable name does not guarantee the same terms.

Common Questions From UK Players

Can I use Google Pay at any UK online casino?

No. Only operators that have integrated Google Pay in their cashier will show it as a deposit option. Many mainstream UKGC casinos do, but not all. Always check the banking page before signing up.

Does Google Pay charge fees for casino deposits?

Google Pay itself does not charge a fee for depositing at a casino. Your linked debit card provider may apply its own rules, but these are the same as a regular online card purchase. No cash advance fees apply.

Can I withdraw casino winnings to Google Pay?

No, Google Pay is not a withdrawal method at UK online casinos. Withdrawals go back to the same debit card, bank transfer, or sometimes an e-wallet. Google Pay is a deposit-only wallet in the gambling space.

Is Google Pay safer than typing my card details into a casino site?

Yes. Google Pay uses tokenization, so the casino never sees your actual card number. You authenticate with your device. That reduces the risk of your card data being exposed in a breach.

Are Google Pay casinos on GamStop?

Every UKGC-licensed casino must be part of GamStop. The operators listed here are all UKGC-licensed and therefore registered with GamStop. Avoid any site claiming to be a UK casino that is not on GamStop.

Casinos That Accept Ethereum UK 2026: Top Ethereum Casino Sites Compared
Casinos That Accept Litecoin UK 2026: The Truth Behind the Search

What is the minimum deposit with Google Pay?

Minimum deposits vary by casino, typically £5 to £10. Google Pay itself does not set a higher minimum. Check the casino’s cashier for the exact amount.

Google Pay may not replace debit cards entirely, but it has carved out a niche for UK casino players who value speed and security. The operators above are a solid starting point if you want to deposit without sharing card details. Just remember: the wallet is only as safe as the casino behind it. Stick to UKGC-licensed sites, read the bonus terms, and never deposit more than you can afford to lose.

Casinos That Accept Google Pay UK 2026: Verified List & Expert Guide

Penyedia Games
Metode Pembayaran
Transfer Bank
Pulsa
E-Money
©2026 MONOLOG365. All rights reserved | 18+