@absolutejs/absolute 0.19.0-beta.212 → 0.19.0-beta.214

package/.absolutejs/cache/angular-linker/cd4015dfcb0e8b06d279f929ba472d70.js

@@ -0,0 +1,122 @@
+/**
+ * @license Angular v21.2.6
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, DOCUMENT, Injectable } from '@angular/core';
+let _DOM = null;
+function getDOM() {
+  return _DOM;
+}
+function setRootDomAdapter(adapter) {
+  _DOM ??= adapter;
+}
+class DomAdapter {}
+class PlatformLocation {
+  historyGo(relativePosition) {
+    throw new Error(ngDevMode ? 'Not implemented' : '');
+  }
+  static ɵfac = function PlatformLocation_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || PlatformLocation)();
+  };
+  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
+    token: PlatformLocation,
+    factory: () => (() => inject(BrowserPlatformLocation))(),
+    providedIn: 'platform'
+  });
+}
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PlatformLocation, [{
+    type: Injectable,
+    args: [{
+      providedIn: 'platform',
+      useFactory: () => inject(BrowserPlatformLocation)
+    }]
+  }], null, null);
+})();
+const LOCATION_INITIALIZED = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'Location Initialized' : '');
+class BrowserPlatformLocation extends PlatformLocation {
+  _location;
+  _history;
+  _doc = inject(DOCUMENT);
+  constructor() {
+    super();
+    this._location = window.location;
+    this._history = window.history;
+  }
+  getBaseHrefFromDOM() {
+    return getDOM().getBaseHref(this._doc);
+  }
+  onPopState(fn) {
+    const window = getDOM().getGlobalEventTarget(this._doc, 'window');
+    window.addEventListener('popstate', fn, false);
+    return () => window.removeEventListener('popstate', fn);
+  }
+  onHashChange(fn) {
+    const window = getDOM().getGlobalEventTarget(this._doc, 'window');
+    window.addEventListener('hashchange', fn, false);
+    return () => window.removeEventListener('hashchange', fn);
+  }
+  get href() {
+    return this._location.href;
+  }
+  get protocol() {
+    return this._location.protocol;
+  }
+  get hostname() {
+    return this._location.hostname;
+  }
+  get port() {
+    return this._location.port;
+  }
+  get pathname() {
+    return this._location.pathname;
+  }
+  get search() {
+    return this._location.search;
+  }
+  get hash() {
+    return this._location.hash;
+  }
+  set pathname(newPath) {
+    this._location.pathname = newPath;
+  }
+  pushState(state, title, url) {
+    this._history.pushState(state, title, url);
+  }
+  replaceState(state, title, url) {
+    this._history.replaceState(state, title, url);
+  }
+  forward() {
+    this._history.forward();
+  }
+  back() {
+    this._history.back();
+  }
+  historyGo(relativePosition = 0) {
+    this._history.go(relativePosition);
+  }
+  getState() {
+    return this._history.state;
+  }
+  static ɵfac = function BrowserPlatformLocation_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || BrowserPlatformLocation)();
+  };
+  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
+    token: BrowserPlatformLocation,
+    factory: () => (() => new BrowserPlatformLocation())(),
+    providedIn: 'platform'
+  });
+}
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(BrowserPlatformLocation, [{
+    type: Injectable,
+    args: [{
+      providedIn: 'platform',
+      useFactory: () => new BrowserPlatformLocation()
+    }]
+  }], () => [], null);
+})();
+export { BrowserPlatformLocation, DomAdapter, LOCATION_INITIALIZED, PlatformLocation, getDOM, setRootDomAdapter };

package/.absolutejs/cache/angular-linker/d7949b8b530e790ee1d7c5f4d9f4e561.js

@@ -0,0 +1,314 @@
+/**
+ * @license Angular v21.2.6
+ * (c) 2010-2026 Google LLC. https://angular.dev/
+ * License: MIT
+ */
+
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, DOCUMENT, Injectable, Optional, Inject, ɵɵinject as __inject } from '@angular/core';
+import { Subject } from 'rxjs';
+import { PlatformLocation } from './_platform_location-chunk.mjs';
+function joinWithSlash(start, end) {
+  if (!start) return end;
+  if (!end) return start;
+  if (start.endsWith('/')) {
+    return end.startsWith('/') ? start + end.slice(1) : start + end;
+  }
+  return end.startsWith('/') ? start + end : `${start}/${end}`;
+}
+function stripTrailingSlash(url) {
+  const pathEndIdx = url.search(/#|\?|$/);
+  return url[pathEndIdx - 1] === '/' ? url.slice(0, pathEndIdx - 1) + url.slice(pathEndIdx) : url;
+}
+function normalizeQueryParams(params) {
+  return params && params[0] !== '?' ? `?${params}` : params;
+}
+class LocationStrategy {
+  historyGo(relativePosition) {
+    throw new Error(ngDevMode ? 'Not implemented' : '');
+  }
+  static ɵfac = function LocationStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || LocationStrategy)();
+  };
+  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
+    token: LocationStrategy,
+    factory: () => (() => inject(PathLocationStrategy))(),
+    providedIn: 'root'
+  });
+}
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LocationStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: 'root',
+      useFactory: () => inject(PathLocationStrategy)
+    }]
+  }], null, null);
+})();
+const APP_BASE_HREF = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'appBaseHref' : '');
+class PathLocationStrategy extends LocationStrategy {
+  _platformLocation;
+  _baseHref;
+  _removeListenerFns = [];
+  constructor(_platformLocation, href) {
+    super();
+    this._platformLocation = _platformLocation;
+    this._baseHref = href ?? this._platformLocation.getBaseHrefFromDOM() ?? inject(DOCUMENT).location?.origin ?? '';
+  }
+  ngOnDestroy() {
+    while (this._removeListenerFns.length) {
+      this._removeListenerFns.pop()();
+    }
+  }
+  onPopState(fn) {
+    this._removeListenerFns.push(this._platformLocation.onPopState(fn), this._platformLocation.onHashChange(fn));
+  }
+  getBaseHref() {
+    return this._baseHref;
+  }
+  prepareExternalUrl(internal) {
+    return joinWithSlash(this._baseHref, internal);
+  }
+  path(includeHash = false) {
+    const pathname = this._platformLocation.pathname + normalizeQueryParams(this._platformLocation.search);
+    const hash = this._platformLocation.hash;
+    return hash && includeHash ? `${pathname}${hash}` : pathname;
+  }
+  pushState(state, title, url, queryParams) {
+    const externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));
+    this._platformLocation.pushState(state, title, externalUrl);
+  }
+  replaceState(state, title, url, queryParams) {
+    const externalUrl = this.prepareExternalUrl(url + normalizeQueryParams(queryParams));
+    this._platformLocation.replaceState(state, title, externalUrl);
+  }
+  forward() {
+    this._platformLocation.forward();
+  }
+  back() {
+    this._platformLocation.back();
+  }
+  getState() {
+    return this._platformLocation.getState();
+  }
+  historyGo(relativePosition = 0) {
+    this._platformLocation.historyGo?.(relativePosition);
+  }
+  static ɵfac = function PathLocationStrategy_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || PathLocationStrategy)(i0.ɵɵinject(PlatformLocation), i0.ɵɵinject(APP_BASE_HREF, 8));
+  };
+  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
+    token: PathLocationStrategy,
+    factory: PathLocationStrategy.ɵfac,
+    providedIn: 'root'
+  });
+}
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(PathLocationStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: 'root'
+    }]
+  }], () => [{
+    type: PlatformLocation
+  }, {
+    type: undefined,
+    decorators: [{
+      type: Optional
+    }, {
+      type: Inject,
+      args: [APP_BASE_HREF]
+    }]
+  }], null);
+})();
+class NoTrailingSlashPathLocationStrategy extends PathLocationStrategy {
+  prepareExternalUrl(internal) {
+    const path = extractUrlPath(internal);
+    if (path.endsWith('/') && path.length > 1) {
+      internal = path.slice(0, -1) + internal.slice(path.length);
+    }
+    return super.prepareExternalUrl(internal);
+  }
+  static ɵfac = /* @__PURE__ */(() => {
+    let ɵNoTrailingSlashPathLocationStrategy_BaseFactory;
+    return function NoTrailingSlashPathLocationStrategy_Factory(__ngFactoryType__) {
+      return (ɵNoTrailingSlashPathLocationStrategy_BaseFactory || (ɵNoTrailingSlashPathLocationStrategy_BaseFactory = i0.ɵɵgetInheritedFactory(NoTrailingSlashPathLocationStrategy)))(__ngFactoryType__ || NoTrailingSlashPathLocationStrategy);
+    };
+  })();
+  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
+    token: NoTrailingSlashPathLocationStrategy,
+    factory: NoTrailingSlashPathLocationStrategy.ɵfac,
+    providedIn: 'root'
+  });
+}
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(NoTrailingSlashPathLocationStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: 'root'
+    }]
+  }], null, null);
+})();
+class TrailingSlashPathLocationStrategy extends PathLocationStrategy {
+  prepareExternalUrl(internal) {
+    const path = extractUrlPath(internal);
+    if (!path.endsWith('/')) {
+      internal = path + '/' + internal.slice(path.length);
+    }
+    return super.prepareExternalUrl(internal);
+  }
+  static ɵfac = /* @__PURE__ */(() => {
+    let ɵTrailingSlashPathLocationStrategy_BaseFactory;
+    return function TrailingSlashPathLocationStrategy_Factory(__ngFactoryType__) {
+      return (ɵTrailingSlashPathLocationStrategy_BaseFactory || (ɵTrailingSlashPathLocationStrategy_BaseFactory = i0.ɵɵgetInheritedFactory(TrailingSlashPathLocationStrategy)))(__ngFactoryType__ || TrailingSlashPathLocationStrategy);
+    };
+  })();
+  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
+    token: TrailingSlashPathLocationStrategy,
+    factory: TrailingSlashPathLocationStrategy.ɵfac,
+    providedIn: 'root'
+  });
+}
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TrailingSlashPathLocationStrategy, [{
+    type: Injectable,
+    args: [{
+      providedIn: 'root'
+    }]
+  }], null, null);
+})();
+function extractUrlPath(url) {
+  const questionMarkOrHashIndex = url.search(/[?#]/);
+  const pathEnd = questionMarkOrHashIndex > -1 ? questionMarkOrHashIndex : url.length;
+  return url.slice(0, pathEnd);
+}
+class Location {
+  _subject = new Subject();
+  _basePath;
+  _locationStrategy;
+  _urlChangeListeners = [];
+  _urlChangeSubscription = null;
+  constructor(locationStrategy) {
+    this._locationStrategy = locationStrategy;
+    const baseHref = this._locationStrategy.getBaseHref();
+    this._basePath = _stripOrigin(stripTrailingSlash(_stripIndexHtml(baseHref)));
+    this._locationStrategy.onPopState(ev => {
+      this._subject.next({
+        'url': this.path(true),
+        'pop': true,
+        'state': ev.state,
+        'type': ev.type
+      });
+    });
+  }
+  ngOnDestroy() {
+    this._urlChangeSubscription?.unsubscribe();
+    this._urlChangeListeners = [];
+  }
+  path(includeHash = false) {
+    return this.normalize(this._locationStrategy.path(includeHash));
+  }
+  getState() {
+    return this._locationStrategy.getState();
+  }
+  isCurrentPathEqualTo(path, query = '') {
+    return this.path() == this.normalize(path + normalizeQueryParams(query));
+  }
+  normalize(url) {
+    return Location.stripTrailingSlash(_stripBasePath(this._basePath, _stripIndexHtml(url)));
+  }
+  prepareExternalUrl(url) {
+    if (url && url[0] !== '/') {
+      url = '/' + url;
+    }
+    return this._locationStrategy.prepareExternalUrl(url);
+  }
+  go(path, query = '', state = null) {
+    this._locationStrategy.pushState(state, '', path, query);
+    this._notifyUrlChangeListeners(this.prepareExternalUrl(path + normalizeQueryParams(query)), state);
+  }
+  replaceState(path, query = '', state = null) {
+    this._locationStrategy.replaceState(state, '', path, query);
+    this._notifyUrlChangeListeners(this.prepareExternalUrl(path + normalizeQueryParams(query)), state);
+  }
+  forward() {
+    this._locationStrategy.forward();
+  }
+  back() {
+    this._locationStrategy.back();
+  }
+  historyGo(relativePosition = 0) {
+    this._locationStrategy.historyGo?.(relativePosition);
+  }
+  onUrlChange(fn) {
+    this._urlChangeListeners.push(fn);
+    this._urlChangeSubscription ??= this.subscribe(v => {
+      this._notifyUrlChangeListeners(v.url, v.state);
+    });
+    return () => {
+      const fnIndex = this._urlChangeListeners.indexOf(fn);
+      this._urlChangeListeners.splice(fnIndex, 1);
+      if (this._urlChangeListeners.length === 0) {
+        this._urlChangeSubscription?.unsubscribe();
+        this._urlChangeSubscription = null;
+      }
+    };
+  }
+  _notifyUrlChangeListeners(url = '', state) {
+    this._urlChangeListeners.forEach(fn => fn(url, state));
+  }
+  subscribe(onNext, onThrow, onReturn) {
+    return this._subject.subscribe({
+      next: onNext,
+      error: onThrow ?? undefined,
+      complete: onReturn ?? undefined
+    });
+  }
+  static normalizeQueryParams = normalizeQueryParams;
+  static joinWithSlash = joinWithSlash;
+  static stripTrailingSlash = stripTrailingSlash;
+  static ɵfac = function Location_Factory(__ngFactoryType__) {
+    return new (__ngFactoryType__ || Location)(i0.ɵɵinject(LocationStrategy));
+  };
+  static ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({
+    token: Location,
+    factory: () => createLocation(),
+    providedIn: 'root'
+  });
+}
+(() => {
+  (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(Location, [{
+    type: Injectable,
+    args: [{
+      providedIn: 'root',
+      useFactory: createLocation
+    }]
+  }], () => [{
+    type: LocationStrategy
+  }], null);
+})();
+function createLocation() {
+  return new Location(__inject(LocationStrategy));
+}
+function _stripBasePath(basePath, url) {
+  if (!basePath || !url.startsWith(basePath)) {
+    return url;
+  }
+  const strippedUrl = url.substring(basePath.length);
+  if (strippedUrl === '' || ['/', ';', '?', '#'].includes(strippedUrl[0])) {
+    return strippedUrl;
+  }
+  return url;
+}
+function _stripIndexHtml(url) {
+  return url.replace(/\/index.html$/, '');
+}
+function _stripOrigin(baseHref) {
+  const isAbsoluteUrl = new RegExp('^(https?:)?//').test(baseHref);
+  if (isAbsoluteUrl) {
+    const [, pathname] = baseHref.split(/\/\/[^\/]+/);
+    return pathname;
+  }
+  return baseHref;
+}
+export { APP_BASE_HREF, Location, LocationStrategy, NoTrailingSlashPathLocationStrategy, PathLocationStrategy, TrailingSlashPathLocationStrategy, joinWithSlash, normalizeQueryParams };