npm - @ecopages/core - Versions diffs - 0.2.0-beta.9 → 0.2.0-rc.1 - Mend

@ecopages/core 0.2.0-beta.9 → 0.2.0-rc.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (624) hide show

package/src/router/client/navigation-lifecycle.test.browser.js ADDED Viewed

@@ -0,0 +1,118 @@
+import { describe, expect, it, vi } from 'vitest';
+import { completeNavigationLifecycle, dispatchAfterSwap, dispatchBeforeSwap, ECO_NAVIGATION_LIFECYCLE_EVENTS, schedulePageLoad, } from './navigation-lifecycle.js';
+describe('navigation lifecycle dispatch', () => {
+    it('dispatches before-swap with newDocument and reload hook', () => {
+        const beforeSwapSpy = vi.fn();
+        document.addEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.BEFORE_SWAP, beforeSwapSpy);
+        try {
+            const newDocument = new DOMParser().parseFromString('<html><body>Next</body></html>', 'text/html');
+            const url = new URL('https://example.test/next');
+            const { requestedReload } = dispatchBeforeSwap(document, {
+                url,
+                direction: 'forward',
+                newDocument,
+            });
+            expect(requestedReload).toBe(false);
+            expect(beforeSwapSpy).toHaveBeenCalledTimes(1);
+            const detail = beforeSwapSpy.mock.calls[0][0].detail;
+            expect(detail.url).toBe(url);
+            expect(detail.direction).toBe('forward');
+            expect(detail.newDocument).toBe(newDocument);
+            expect(typeof detail.reload).toBe('function');
+        }
+        finally {
+            document.removeEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.BEFORE_SWAP, beforeSwapSpy);
+        }
+    });
+    it('reports reload requests from before-swap listeners', () => {
+        const beforeSwapSpy = vi.fn((event) => {
+            event.detail.reload();
+        });
+        document.addEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.BEFORE_SWAP, beforeSwapSpy);
+        try {
+            const { requestedReload } = dispatchBeforeSwap(document, {
+                url: new URL('https://example.test/reload'),
+                direction: 'forward',
+                newDocument: document,
+            });
+            expect(requestedReload).toBe(true);
+        }
+        finally {
+            document.removeEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.BEFORE_SWAP, beforeSwapSpy);
+        }
+    });
+    it('dispatches after-swap with url and direction', () => {
+        const afterSwapSpy = vi.fn();
+        document.addEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.AFTER_SWAP, afterSwapSpy);
+        try {
+            const url = new URL('https://example.test/after');
+            dispatchAfterSwap(document, { url, direction: 'replace' });
+            expect(afterSwapSpy).toHaveBeenCalledTimes(1);
+            const detail = afterSwapSpy.mock.calls[0][0].detail;
+            expect(detail.url).toBe(url);
+            expect(detail.direction).toBe('replace');
+        }
+        finally {
+            document.removeEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.AFTER_SWAP, afterSwapSpy);
+        }
+    });
+    it('completes navigation lifecycle with after-swap and page-load', () => {
+        const afterSwapSpy = vi.fn();
+        const pageLoadSpy = vi.fn();
+        const scheduleSpy = vi.fn((callback) => {
+            callback(0);
+            return 1;
+        });
+        document.addEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.AFTER_SWAP, afterSwapSpy);
+        document.addEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.PAGE_LOAD, pageLoadSpy);
+        try {
+            const url = new URL('https://example.test/complete');
+            completeNavigationLifecycle(document, { url, direction: 'forward' }, { schedule: scheduleSpy });
+            expect(afterSwapSpy).toHaveBeenCalledTimes(1);
+            expect(pageLoadSpy).toHaveBeenCalledTimes(1);
+            expect(scheduleSpy).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            document.removeEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.AFTER_SWAP, afterSwapSpy);
+            document.removeEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.PAGE_LOAD, pageLoadSpy);
+        }
+    });
+    it('schedules page-load on the next animation frame', () => {
+        const pageLoadSpy = vi.fn();
+        const scheduleSpy = vi.fn((callback) => {
+            callback(0);
+            return 1;
+        });
+        document.addEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.PAGE_LOAD, pageLoadSpy);
+        try {
+            const url = new URL('https://example.test/page-load');
+            schedulePageLoad(document, { url, direction: 'forward' }, { schedule: scheduleSpy });
+            expect(scheduleSpy).toHaveBeenCalledTimes(1);
+            expect(pageLoadSpy).toHaveBeenCalledTimes(1);
+            const detail = pageLoadSpy.mock.calls[0][0].detail;
+            expect(detail.url).toBe(url);
+            expect(detail.direction).toBe('forward');
+        }
+        finally {
+            document.removeEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.PAGE_LOAD, pageLoadSpy);
+        }
+    });
+    it('skips page-load when navigation becomes stale before the frame callback', () => {
+        const pageLoadSpy = vi.fn();
+        let stale = true;
+        document.addEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.PAGE_LOAD, pageLoadSpy);
+        try {
+            schedulePageLoad(document, { url: new URL('https://example.test/stale'), direction: 'forward' }, {
+                isStale: () => stale,
+                schedule: (callback) => {
+                    callback(0);
+                    return 1;
+                },
+            });
+            expect(pageLoadSpy).not.toHaveBeenCalled();
+        }
+        finally {
+            document.removeEventListener(ECO_NAVIGATION_LIFECYCLE_EVENTS.PAGE_LOAD, pageLoadSpy);
+        }
+    });
+});

package/src/router/server/route-registry.js CHANGED Viewed

@@ -1,262 +1,257 @@
-import path from "node:path";
-import { existsSync } from "node:fs";
-import { fileSystem } from "@ecopages/file-system";
-import { appLogger } from "../../global/app-logger.js";
-import { invariant } from "../../utils/invariant.js";
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { fileSystem } from '@ecopages/file-system';
+import { appLogger } from '../../global/app-logger.js';
+import { invariant } from '../../utils/invariant.js';
 const ROUTE_PRIORITY = {
-  exact: 0,
-  dynamic: 1,
-  "catch-all": 2
+    exact: 0,
+    dynamic: 1,
+    'catch-all': 2,
 };
-class RouteRegistry {
-  origin;
-  appConfig;
-  pagesDir;
-  templatesExt;
-  buildMode;
-  pageModuleAdapter;
-  templateRouteList = [];
-  reloadListeners = /* @__PURE__ */ new Set();
-  constructor(options) {
-    this.origin = options.origin;
-    this.appConfig = options.appConfig;
-    this.pagesDir = options.pagesDir;
-    this.templatesExt = options.templatesExt;
-    this.buildMode = options.buildMode;
-    this.pageModuleAdapter = options.pageModuleAdapter;
-  }
-  get templateRoutes() {
-    return this.templateRouteList;
-  }
-  async init() {
-    this.templateRouteList = await this.scanTemplateRoutes();
-    appLogger.debug("RouteRegistry initialized", this.templateRouteList);
-  }
-  async reload() {
-    await this.init();
-    for (const listener of this.reloadListeners) {
-      listener();
+export class RouteRegistry {
+    origin;
+    appConfig;
+    pagesDir;
+    templatesExt;
+    buildMode;
+    pageModuleAdapter;
+    templateRouteList = [];
+    reloadListeners = new Set();
+    constructor(options) {
+        this.origin = options.origin;
+        this.appConfig = options.appConfig;
+        this.pagesDir = options.pagesDir;
+        this.templatesExt = options.templatesExt;
+        this.buildMode = options.buildMode;
+        this.pageModuleAdapter = options.pageModuleAdapter;
     }
-  }
-  onReload(listener) {
-    this.reloadListeners.add(listener);
-    return () => {
-      this.reloadListeners.delete(listener);
-    };
-  }
-  matchRequest(requestUrl) {
-    const url = new URL(requestUrl);
-    const requestedPathname = normalizePathname(url.pathname);
-    const query = this.getSearchParams(url);
-    for (const route of this.templateRouteList) {
-      if (route.kind !== "exact") {
-        continue;
-      }
-      if (requestedPathname === route.pathname || requestedPathname === `${route.pathname}/`) {
-        return {
-          requestedPathname,
-          templateRoute: route,
-          params: {},
-          query
-        };
-      }
+    get templateRoutes() {
+        return this.templateRouteList;
     }
-    for (const route of this.templateRouteList) {
-      if (route.kind !== "dynamic") {
-        continue;
-      }
-      const params = this.tryExtractParams(route, requestedPathname);
-      if (!params) {
-        continue;
-      }
-      return {
-        requestedPathname,
-        templateRoute: route,
-        params,
-        query
-      };
+    async init() {
+        this.templateRouteList = await this.scanTemplateRoutes();
+        appLogger.debug('RouteRegistry initialized', this.templateRouteList);
     }
-    for (const route of this.templateRouteList) {
-      if (route.kind !== "catch-all") {
-        continue;
-      }
-      const params = this.tryExtractParams(route, requestedPathname);
-      if (!params) {
-        continue;
-      }
-      return {
-        requestedPathname,
-        templateRoute: route,
-        params,
-        query
-      };
+    async reload() {
+        await this.init();
+        for (const listener of this.reloadListeners) {
+            listener();
+        }
     }
-    return null;
-  }
-  async listStaticPathExpansions(input) {
-    const expansions = [];
-    for (const route of this.templateRouteList) {
-      if (route.kind === "exact") {
-        continue;
-      }
-      const pageModule = await this.pageModuleAdapter.loadPageModule(route.filePath);
-      const staticPaths = pageModule.staticPaths;
-      if (this.buildMode) {
-        invariant(staticPaths !== void 0, `[ecopages] Missing getStaticPaths in ${route.filePath}`);
-        invariant(
-          pageModule.staticProps !== void 0,
-          `[ecopages] Missing getStaticProps in ${route.filePath}`
-        );
-      }
-      if (!staticPaths) {
-        continue;
-      }
-      const result = await staticPaths({
-        appConfig: this.appConfig,
-        runtimeOrigin: input.runtimeOrigin
-      });
-      for (const { params } of result.paths) {
-        expansions.push({
-          pathname: this.resolveTemplatePath(route.pathname, params),
-          templateRoute: route,
-          params
-        });
-      }
+    onReload(listener) {
+        this.reloadListeners.add(listener);
+        return () => {
+            this.reloadListeners.delete(listener);
+        };
     }
-    return expansions;
-  }
-  async listStaticGenerationRoutes(input) {
-    const staticPathExpansions = await this.listStaticPathExpansions(input);
-    return [
-      ...this.templateRouteList.filter((route) => route.kind === "exact").map((route) => ({
-        requestUrl: `${input.runtimeOrigin}${route.pathname}`,
-        pathname: route.pathname,
-        templateRoute: route,
-        params: {}
-      })),
-      ...staticPathExpansions.map((route) => ({
-        requestUrl: `${input.runtimeOrigin}${route.pathname}`,
-        pathname: route.pathname,
-        templateRoute: route.templateRoute,
-        params: route.params
-      }))
-    ];
-  }
-  async scanTemplateRoutes() {
-    if (!existsSync(this.pagesDir)) {
-      return [];
+    matchRequest(requestUrl) {
+        const url = new URL(requestUrl);
+        const requestedPathname = normalizePathname(url.pathname);
+        const query = this.getSearchParams(url);
+        for (const route of this.templateRouteList) {
+            if (route.kind !== 'exact') {
+                continue;
+            }
+            if (requestedPathname === route.pathname || requestedPathname === `${route.pathname}/`) {
+                return {
+                    requestedPathname,
+                    templateRoute: route,
+                    params: {},
+                    query,
+                };
+            }
+        }
+        for (const route of this.templateRouteList) {
+            if (route.kind !== 'dynamic') {
+                continue;
+            }
+            const params = this.tryExtractParams(route, requestedPathname);
+            if (!params) {
+                continue;
+            }
+            return {
+                requestedPathname,
+                templateRoute: route,
+                params,
+                query,
+            };
+        }
+        for (const route of this.templateRouteList) {
+            if (route.kind !== 'catch-all') {
+                continue;
+            }
+            const params = this.tryExtractParams(route, requestedPathname);
+            if (!params) {
+                continue;
+            }
+            return {
+                requestedPathname,
+                templateRoute: route,
+                params,
+                query,
+            };
+        }
+        return null;
     }
-    const scannedFiles = await fileSystem.glob(
-      this.templatesExt.map((ext) => `**/*${ext}`),
-      {
-        cwd: this.pagesDir
-      }
-    );
-    const templateRoutes = [];
-    for await (const file of scannedFiles) {
-      if (file.includes(".ecopages-node.")) {
-        continue;
-      }
-      const routePathname = this.getRoutePath(file);
-      const filePath = path.join(this.pagesDir, file);
-      const kind = this.classifyRouteKind(filePath);
-      templateRoutes.push({
-        pathname: routePathname,
-        kind,
-        filePath,
-        paramNames: this.getParamNames(routePathname)
-      });
+    async listStaticPathExpansions(input) {
+        const expansions = [];
+        for (const route of this.templateRouteList) {
+            if (route.kind === 'exact') {
+                continue;
+            }
+            const pageModule = await this.pageModuleAdapter.loadPageModule(route.filePath);
+            const staticPaths = pageModule.staticPaths;
+            if (this.buildMode) {
+                invariant(staticPaths !== undefined, `[ecopages] Missing getStaticPaths in ${route.filePath}`);
+                invariant(pageModule.staticProps !== undefined, `[ecopages] Missing getStaticProps in ${route.filePath}`);
+            }
+            if (!staticPaths) {
+                continue;
+            }
+            const result = await staticPaths({
+                appConfig: this.appConfig,
+                runtimeOrigin: input.runtimeOrigin,
+            });
+            for (const { params } of result.paths) {
+                expansions.push({
+                    pathname: this.resolveTemplatePath(route.pathname, params),
+                    templateRoute: route,
+                    params,
+                });
+            }
+        }
+        return expansions;
     }
-    return templateRoutes.sort((left, right) => {
-      const priorityDifference = ROUTE_PRIORITY[left.kind] - ROUTE_PRIORITY[right.kind];
-      if (priorityDifference !== 0) {
-        return priorityDifference;
-      }
-      if (left.pathname === "/") {
-        return -1;
-      }
-      if (right.pathname === "/") {
-        return 1;
-      }
-      return left.pathname.localeCompare(right.pathname);
-    });
-  }
-  getRoutePath(file) {
-    const cleanedRoute = this.templatesExt.reduce((route, ext) => route.replace(ext, ""), file).replace(/\/?index$/, "");
-    return normalizePathname(`/${cleanedRoute}`);
-  }
-  classifyRouteKind(filePath) {
-    if (filePath.includes("[...")) {
-      return "catch-all";
+    async listStaticGenerationRoutes(input) {
+        const staticPathExpansions = await this.listStaticPathExpansions(input);
+        return [
+            ...this.templateRouteList
+                .filter((route) => route.kind === 'exact')
+                .map((route) => ({
+                requestUrl: `${input.runtimeOrigin}${route.pathname}`,
+                pathname: route.pathname,
+                templateRoute: route,
+                params: {},
+            })),
+            ...staticPathExpansions.map((route) => ({
+                requestUrl: `${input.runtimeOrigin}${route.pathname}`,
+                pathname: route.pathname,
+                templateRoute: route.templateRoute,
+                params: route.params,
+            })),
+        ];
     }
-    if (filePath.includes("[") && filePath.includes("]")) {
-      return "dynamic";
+    async scanTemplateRoutes() {
+        if (!existsSync(this.pagesDir)) {
+            return [];
+        }
+        const scannedFiles = await fileSystem.glob(this.templatesExt.map((ext) => `**/*${ext}`), {
+            cwd: this.pagesDir,
+        });
+        const templateRoutes = [];
+        for await (const file of scannedFiles) {
+            if (file.includes('.ecopages-node.')) {
+                continue;
+            }
+            const routePathname = this.getRoutePath(file);
+            const filePath = path.join(this.pagesDir, file);
+            const kind = this.classifyRouteKind(filePath);
+            templateRoutes.push({
+                pathname: routePathname,
+                kind,
+                filePath,
+                paramNames: this.getParamNames(routePathname),
+            });
+        }
+        return templateRoutes.sort((left, right) => {
+            const priorityDifference = ROUTE_PRIORITY[left.kind] - ROUTE_PRIORITY[right.kind];
+            if (priorityDifference !== 0) {
+                return priorityDifference;
+            }
+            if (left.pathname === '/') {
+                return -1;
+            }
+            if (right.pathname === '/') {
+                return 1;
+            }
+            return left.pathname.localeCompare(right.pathname);
+        });
     }
-    return "exact";
-  }
-  getParamNames(routePathname) {
-    const matches = routePathname.match(/\[(?:\.\.\.)?([^\]]+)\]/g);
-    return matches ? matches.map((match) => match.replace(/^\[(?:\.\.\.)?/, "").replace(/\]$/, "")) : [];
-  }
-  tryExtractParams(route, requestedPathname) {
-    const routeParts = route.pathname.split("/");
-    const pathnameParts = requestedPathname.split("/");
-    if (route.kind === "dynamic" && routeParts.length !== pathnameParts.length) {
-      return null;
+    getRoutePath(file) {
+        const cleanedRoute = this.templatesExt
+            .reduce((route, ext) => route.replace(ext, ''), file)
+            .replace(/\/?index$/, '');
+        return normalizePathname(`/${cleanedRoute}`);
     }
-    const params = {};
-    for (let i = 0; i < routeParts.length; i++) {
-      const routePart = routeParts[i];
-      const pathnamePart = pathnameParts[i];
-      if (!routePart) {
-        continue;
-      }
-      if (routePart.startsWith("[...") && routePart.endsWith("]")) {
-        const paramName = routePart.slice(4, -1);
-        params[paramName] = pathnameParts.slice(i).filter(Boolean);
-        return params;
-      }
-      if (routePart.startsWith("[") && routePart.endsWith("]")) {
-        if (pathnamePart === void 0) {
-          return null;
+    classifyRouteKind(filePath) {
+        if (filePath.includes('[...')) {
+            return 'catch-all';
         }
-        params[routePart.slice(1, -1)] = pathnamePart;
-        continue;
-      }
-      if (routePart !== pathnamePart) {
-        return null;
-      }
+        if (filePath.includes('[') && filePath.includes(']')) {
+            return 'dynamic';
+        }
+        return 'exact';
     }
-    if (route.kind === "catch-all") {
-      const cleanPathname = route.pathname.replace(/\[.*?\]/g, "");
-      return requestedPathname.includes(cleanPathname) ? params : null;
+    getParamNames(routePathname) {
+        const matches = routePathname.match(/\[(?:\.\.\.)?([^\]]+)\]/g);
+        return matches ? matches.map((match) => match.replace(/^\[(?:\.\.\.)?/, '').replace(/\]$/, '')) : [];
+    }
+    tryExtractParams(route, requestedPathname) {
+        const routeParts = route.pathname.split('/');
+        const pathnameParts = requestedPathname.split('/');
+        if (route.kind === 'dynamic' && routeParts.length !== pathnameParts.length) {
+            return null;
+        }
+        const params = {};
+        for (let i = 0; i < routeParts.length; i++) {
+            const routePart = routeParts[i];
+            const pathnamePart = pathnameParts[i];
+            if (!routePart) {
+                continue;
+            }
+            if (routePart.startsWith('[...') && routePart.endsWith(']')) {
+                const paramName = routePart.slice(4, -1);
+                params[paramName] = pathnameParts.slice(i).filter(Boolean);
+                return params;
+            }
+            if (routePart.startsWith('[') && routePart.endsWith(']')) {
+                if (pathnamePart === undefined) {
+                    return null;
+                }
+                params[routePart.slice(1, -1)] = pathnamePart;
+                continue;
+            }
+            if (routePart !== pathnamePart) {
+                return null;
+            }
+        }
+        if (route.kind === 'catch-all') {
+            const cleanPathname = route.pathname.replace(/\[.*?\]/g, '');
+            return requestedPathname.includes(cleanPathname) ? params : null;
+        }
+        return params;
     }
-    return params;
-  }
-  getSearchParams(url) {
-    const query = {};
-    for (const [key, value] of url.searchParams) {
-      query[key] = value;
+    getSearchParams(url) {
+        const query = {};
+        for (const [key, value] of url.searchParams) {
+            query[key] = value;
+        }
+        return query;
     }
-    return query;
-  }
-  resolveTemplatePath(pathname, params) {
-    let resolvedPath = pathname;
-    for (const [key, value] of Object.entries(params)) {
-      const serializedValue = Array.isArray(value) ? value.join("/") : value;
-      resolvedPath = resolvedPath.replace(`[...${key}]`, serializedValue);
-      resolvedPath = resolvedPath.replace(`[${key}]`, serializedValue);
+    resolveTemplatePath(pathname, params) {
+        let resolvedPath = pathname;
+        for (const [key, value] of Object.entries(params)) {
+            const serializedValue = Array.isArray(value) ? value.join('/') : value;
+            resolvedPath = resolvedPath.replace(`[...${key}]`, serializedValue);
+            resolvedPath = resolvedPath.replace(`[${key}]`, serializedValue);
+        }
+        return normalizePathname(resolvedPath);
     }
-    return normalizePathname(resolvedPath);
-  }
 }
 function normalizePathname(pathname) {
-  if (!pathname || pathname === "/") {
-    return "/";
-  }
-  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
-  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+    if (!pathname || pathname === '/') {
+        return '/';
+    }
+    const normalized = pathname.startsWith('/') ? pathname : `/${pathname}`;
+    return normalized.endsWith('/') ? normalized.slice(0, -1) : normalized;
 }
-export {
-  RouteRegistry
-};

package/src/services/README.md CHANGED Viewed

@@ -18,11 +18,16 @@ Typical responsibilities include:
 - `module-loading/`: framework-owned config/app bootstrap loading and server-side source loading
 - `assets/`: shared browser build coordination and processed asset pipelines
+- `cache/`: page HTML cache stores, selective source-path invalidation, and request coordination
 - `invalidation/`: file-change classification and invalidation policy
 - `runtime-state/`: app-owned invalidation state and dependency graphs
 - `runtime-manifest/`: node runtime manifest derivation and persistence
 - `html/`: final HTML dependency injection and rewriter selection
+The asset-processing service caches emitted file assets by source identity in development as well as production.
+When a source file changes, its source hash or explicit invalidation removes the cached asset before the next render,
+so shared layout styles do not need to be rebuilt for every navigated page while HMR remains fresh.
 ## Design Rule
 If a concern affects more than one integration or more than one runtime adapter, it usually belongs here instead of in a package-specific implementation.

package/src/services/assets/asset-processing-service/asset-dependency-keys.d.ts CHANGED Viewed

@@ -1,3 +1,16 @@
 import type { AssetDefinition } from './assets.types.js';
+/**
+ * Stable identity for dependency deduplication and {@link AssetProcessingService} cache lookups.
+ *
+ * @remarks
+ * Script dependencies include a build signature derived from bundle flags, grouped-bundle
+ * metadata, and selected `bundleOptions` fields (`naming`, `external`, `minify`, plugin names).
+ * HTML-affecting script `attributes` are hashed into the key so dedupe and cache reuse do not
+ * collapse declarations that would emit different `<script>` tags. Full plugin objects and
+ * `NODE_ENV` are excluded from the key.
+ *
+ * Runtime minify in {@link ContentScriptProcessor} still follows `NODE_ENV` via
+ * `isProduction`, not `bundleOptions.minify`.
+ */
 export declare function getAssetDependencyKey(dep: AssetDefinition): string;
 export declare function deduplicateAssetDependencies(deps: AssetDefinition[]): AssetDefinition[];