@noego/forge 0.0.1

package/README.md

@@ -0,0 +1,620 @@
+# @noego/forge
+
+[![NPM Version](https://img.shields.io/npm/v/@noego/forge.svg)](https://www.npmjs.com/package/@noego/forge)
+[![License](https://img.shields.io/npm/l/@noego/forge.svg)](LICENSE)
+
+**OpenAPI-Powered Svelte SSR Framework** - Build server-rendered Svelte applications with routes generated directly from your OpenAPI specification.
+
+## Overview
+
+Forge is a framework that generates Svelte applications from OpenAPI definitions, combining server-side rendering (SSR) with client-side navigation.  
+You get **fast first paint & SEO** (SSR) *and* **instant page transitions** (client-side routing) without writing a single line of glue code.
+
+📝 **Just want to see it run?**  Jump to the *TL;DR* section below and paste the two commands – you’ll have a working demo at `http://localhost:3000`.
+
+### Key Features
+
+- **OpenAPI-Driven Development**: Define routes, views, and layouts directly in your OpenAPI spec
+- **Server-Side Rendering**: Deliver fully rendered HTML on first load for SEO and performance
+- **Client-Side Navigation**: Smooth, fast transitions after initial load
+- **Nested Layouts**: Create complex page structures with multiple layout levels
+- **Automatic Parameter Parsing**: Route parameters (like `/users/:id`) are parsed from OpenAPI paths
+- **Data Loading**: Unified mechanism for data fetching in SSR and client-side
+- **Vite Integration**: Modern, fast development with hot module reloading
+
+## Quick Start
+
+### TL;DR – Run the demo in two commands 🚀
+
+```bash
+# 1. Install dependencies (Forge + peers)
+npm install   # or pnpm / yarn
+
+# 2. Launch the development server (Express *and* Vite)
+npm run dev   # -> http://localhost:3000
+```
+
+Vite is wired up as **middleware** inside Express (`middlewareMode: true`).
+That means hot-module-reloading, static files, and SSR all live behind the
+same port – you only ever need to open http://localhost:3000.
+
+### Installation
+
+```bash
+npm i @noego/forge express svelte
+```
+
+Forge is a thin wrapper around **Express** and **Svelte**. The command above installs all three runtime dependencies you need. For development, you'll also want Vite for hot-module-reloading:
+
+```bash
+# development-only (HMR, build, …)
+npm i -D vite
+```
+
+The versions shown in the badge at the very top are always the ones that Forge
+is tested against; newer minor / patch releases of Express and Svelte usually
+work fine as well.
+
+### Basic Setup
+
+## Example Project Structure
+
+Forge is completely agnostic about where you place your files – as long as the
+paths in your **options object** are correct everything will “just work”.  To make the
+following snippets less abstract, here is one possible layout for a **full
+stack** repository:
+
+```
+.
+├─ frontend/             # Svelte + Forge source code
+│  ├─ components/
+│  ├─ openapi.yaml
+│  ├─ client.ts          # client hydration entry
+│  └─ server.ts          # Express SSR entry
+├─ backend/              # (optional) REST / database code
+├─ vite.config.js        # shared by both dev & prod builds
+├─ forge.config.ts       # (optional) central Forge options shared by client & server
+└─ package.json          # root-level scripts & deps
+```
+
+Feel free to flatten or reorganise folders – if you move `components/` for
+instance, simply update `component_dir` and the import paths keep resolving
+correctly.
+
+### How Forge resolves paths
+
+Forge only really needs three absolute paths to bootstrap your app:
+
+1. **`component_dir`** – look here for Svelte files referenced in the OpenAPI
+   schema (every `x-view` / `x-layout` is interpreted *relative* to this
+   directory).
+2. **`open_api_path`** – the location of your `openapi.yaml`.
+3. **`renderer`** – an HTML template that contains the placeholders
+   `{{{APP}}}`, `{{{HEAD}}}` and `{{{DATA}}}`.
+
+All paths are resolved against **`process.cwd()`** (your *project root*):
+
+* **Relative strings** – the preferred form. Pass `frontend/components` instead
+  of `./frontend/components` so that the value still resolves correctly when
+  your working directory changes (for instance when running tests).
+* **Absolute strings starting with `/`** – treated as root-relative, e.g.
+  `/frontend/components` ➜ `path.join(process.cwd(), 'frontend/components')`.
+
+Avoid the `./` prefix – while it works most of the time it breaks as soon as you
+invoke Node from a different folder.
+
+1. **Configure OpenAPI Schema**
+
+Forge extends the OpenAPI 3 spec with a couple of `x-*` vendor extensions.  Two
+conventions are important from day one:
+
+* **Landing page must be explicit** – declare the `/` path manually, Forge will
+  not create a default route for you.
+* **`x-layout` is always an array** – even when there is only one layout
+  component.  That keeps the type consistent and makes it possible to add more
+  wrappers later without touching already deployed code.
+
+Create `openapi.yaml` in your project root:
+
+```yaml
+openapi: '3.0.3'
+info:
+  title: My App
+  version: '1.0.0'
+
+x-fallback-view: error/404.svelte # 404 page
+
+paths:
+  /:
+    get:
+      summary: Home page
+      x-view: views/home.svelte
+      x-layout: 
+        - layout/main.svelte
+  
+  '/user/:id':
+    get:
+      summary: User profile
+      x-view: views/user_page.svelte
+      x-layout: 
+        - layout/main.svelte
+```
+
+2. **Build (but don’t start) the Express server**
+
+Keeping server construction and `listen()` separate makes automated testing a
+lot easier because you can import the app without opening a TCP port.
+
+```ts
+// server.ts – returns a fully configured Express application
+import express from 'express';
+import { createServer } from '@noego/forge/server';
+import { options } from './forge.config';
+
+export async function buildServer() {
+  const app = express();
+  await createServer(app, options);
+  return app;
+}
+```
+
+3. **Start the server in dev / prod scripts**
+
+Your actual entry file is now a tiny wrapper that calls `buildServer()` and then
+`listen()`.  Swap it out for a different bootstrapper in tests.
+
+```ts
+// dev.ts – used by `npm run dev`
+import { buildServer } from './server';
+
+const PORT = process.env.PORT ?? 3000;
+
+buildServer()
+  .then(app => app.listen(PORT))
+  .then(() => console.log(`🚀  http://localhost:${PORT}`))
+  .catch(err => {
+    console.error('Server failed to start', err);
+    process.exit(1);
+  });
+```
+
+4. **Create Client Initialization File**
+
+```typescript
+// client.ts
+import { createApp } from '@noego/forge/client';
+import { options } from './forge.config';
+
+document.addEventListener('DOMContentLoaded', () => {
+  createApp(document.getElementById('app'), options);
+});
+```
+
+5. **Create HTML Template**
+
+```html
+<!-- index.html -->
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>My Forge App</title>
+  <!-- 👇👇 **Important for Vite HMR during development** 👇👇  -->
+  <!-- This script connects the page to Vite's Hot-Module-Reloading client.            -->
+  <!-- It MUST be included before your own client bundle when running the dev server. -->
+  <!-- Vite HMR client (served from project root) -->
+  <script type="module" src="/@vite/client"></script>
+  <style>{{{CSS}}}</style>
+  {{{HEAD}}}
+</head>
+<body>
+  <div id="app">{{{APP}}}</div>
+  <script>window.__INITIAL_DATA__ = {{{DATA}}};</script>
+  <!-- Application client entry (served from Vite dev server root) -->
+  <script type="module" src="/client.ts"></script>
+</body>
+</html>
+```
+
+6. **Provide Forge Options** (file name & language are totally up to you)
+
+```ts
+// forge.config.ts  (could also be .js / .mjs – only the exported object matters)
+import type { ServerOptions } from '@noego/forge/options';
+
+export const options: ServerOptions = {
+  component_dir: 'components',
+  renderer: 'index.html',
+  assets: {
+    '/assets': ['public']
+  },
+  open_api_path: 'openapi.yaml',
+};
+```
+
+7. **Create Components**
+
+```html
+<!-- components/layout/main.svelte -->
+<script>
+  let { children } = $props();
+</script>
+
+<nav>
+  <a href="/">Home</a>
+  <a href="/user/1">User</a>
+</nav>
+<main>
+  {@render children()}
+</main>
+
+<!-- components/views/home.svelte -->
+<h1>Welcome to my app!</h1>
+
+<!-- components/views/user_page.svelte -->
+<script>
+  export let params = {};
+</script>
+
+<h1>User {params.id}</h1>
+
+<!-- components/error/404.svelte -->
+<h1>Page not found</h1>
+```
+
+8. **Start Development Server**
+
+Add to your package.json:
+```json
+"scripts": {
+  "dev": "tsx dev.ts",
+  "watch": "tsx watch --ignore '**/*.svelte' dev.ts",
+  "typecheck": "tsc --noEmit && svelte-check"
+}
+```
+
+Run the server:
+```bash
+npm run dev
+```
+
+## Available npm scripts
+
+| Script | What it does |
+|--------|--------------|
+| `dev` | Express + Vite with HMR (default development mode) |
+| `watch` | Restarts Express when server-side files change |
+| `build` | Generates both client & SSR bundles (`vite build` twice) |
+| `typecheck` | Runs `tsc` and `svelte-check` |
+
+## Further documentation 📚
+
+The README is only the quick-start.  For deeper topics have a look at the
+markdown files under [`/docs`](./docs):
+
+| Document | What you will find |
+|----------|--------------------|
+| **layout_system.md** | How Forge composes nested layouts and views, best-practices, common pitfalls, and design guidelines. |
+| **load_functions.md** | How to fetch data safely on the server with `load()`, have it ready for SSR and client-side navigation, and access it via `$props()`. |
+| **state_sharing.md** | Pattern for reactive global state with Svelte 5 context and `$state`, including multi-property examples. |
+| **tailwind-layouts.md** | Design layouts with Tailwind CSS: global shells, nested wrappers, responsive tips. |
+| **FETCH_MIDDLEWARE.md** | Client-side fetch middleware: header injection, redirect handling, debugging helpers, security notes. |
+
+More docs will be added over time—keep an eye on the folder when upgrading.
+
+9. **Create a `vite.config.js` (if you don't already have one)**
+
+Forge relies on Vite for both development (HMR) and production builds.  
+If your project was scaffolded from scratch you will need to add a minimal
+`vite.config.js` file at the root of the repository so Vite knows how to handle
+Svelte files:
+
+```js
+// vite.config.js
+import { defineConfig } from 'vite';
+import { svelte } from '@sveltejs/vite-plugin-svelte';
+
+export default defineConfig({
+  plugins: [svelte()],
+});
+```
+
+This can of course be extended with any additional Vite options that your
+application requires – the only strict requirement is that the Svelte plugin is
+present so that `*.svelte` files are compiled correctly.
+
+## Configuration Options
+
+### Server Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `development` | boolean | `process.env.NODE_ENV !== 'production'` | Development mode flag |
+| `component_dir` | string | `/` | Directory containing Svelte components |
+| `build_dir` | string | `dist_ssr` | Output directory for production builds |
+| `renderer` | string \| IHTMLRender | `default` | HTML template path or renderer |
+| `open_api_path` | string | `process.cwd() + '/openapi.yaml'` | Path to OpenAPI specification |
+| `manifest_endpoint` | string | `/manifest.json` | Endpoint for manifest file |
+| `assets` | Record<string, string[]> | `undefined` | Map of URL paths to directories for static assets |
+| `viteOptions` | object | See code | Vite configuration options |
+
+### OpenAPI Extensions
+
+Forge uses custom OpenAPI extensions to define your application structure:
+
+| Extension | Description |
+|-----------|-------------|
+| `x-view` | Path to the Svelte component that handles the route |
+| `x-layout` | Array of layout components that wrap the view (rendered outside-in) |
+| `x-fallback-view` | Component to render for 404 errors |
+| `x-fallback-layout` | Default layout when none is specified |
+
+## Advanced Usage
+
+### Fetch Middleware for Authentication
+
+Forge provides a client-side fetch middleware system that allows you to automatically modify all fetch requests, eliminating the need to manually add authentication headers to every API call.
+
+```typescript
+// client.ts
+import { createApp, fetch } from '@noego/forge/client';
+import { options } from './forge.config';
+
+// Configure fetch middleware to automatically add authentication headers
+fetch.configUpdate((url, init) => {
+  const token = localStorage.getItem('auth_token');
+  if (token) {
+    const headers = new Headers(init?.headers);
+    headers.set('Authorization', `Bearer ${token}`);
+    return {
+      ...init,
+      headers
+    };
+  }
+  return init;
+});
+
+document.addEventListener('DOMContentLoaded', () => {
+  createApp(document.getElementById('app'), options);
+});
+```
+
+With this middleware configured, all fetch calls in your application will automatically include the Authorization header:
+
+```typescript
+// No need to manually add Authorization headers anymore
+const response = await fetch('/api/contractor-types', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ name: 'New Type' })
+});
+```
+
+The middleware function receives the same parameters as the native `fetch()` function and should return the modified `RequestInit` object. You can use this pattern for:
+
+- Adding authentication tokens
+- Setting default headers
+- Logging requests
+- Transforming request data
+
+### Nested Layouts
+
+Forge supports nested layouts, rendered in the order specified:
+
+```yaml
+paths:
+  '/product/:id':
+    get:
+      x-view: views/product_page.svelte      # 👈 view component
+      x-layout:
+        - layout/main.svelte                # outer layout
+        - layout/product_layout.svelte      # inner (page-specific) layout
+```
+
+The resulting component tree:
+```
+main.svelte
+  └── product_layout.svelte
+        └── product_page.svelte (view)
+```
+
+### Static Assets
+
+Configure multiple asset directories:
+
+```typescript
+assets: {
+  '/assets': ['public'],
+  '/images': ['resources/images'],
+  '/docs': ['documentation']
+}
+```
+
+⚠ **Important:** every directory listed in `assets` *must* exist at server
+start-up, otherwise `express.static` will throw an error and Forge will refuse to
+boot.  If you need to commit an empty folder simply add a dummy
+`public/.gitkeep` file so the directory makes it into version control.
+
+### Component Data Loading
+
+Svelte components can export a **server-only** `load` function that returns the
+initial data for the page.
+
+Forge will:
+1. Invoke `load()` during SSR and embed the returned JSON into the HTML.
+2. On subsequent **client-side navigations** automatically issue an
+   `application/json` request to the same URL and pass the payload to the
+   destination component – you don’t have to write any extra code.
+
+```html
+<script lang="ts">
+  export let data: any;  // data returned by `load()`
+
+  /**
+   * `load()` is executed exactly once on the server.
+   * It receives a single argument – an object that describes the incoming
+   * request.  Forge then serialises the returned value and re-hydrates it on
+   * the client (or performs an automatic JSON fetch when navigating
+   * client-side).
+   */
+  export async function load(request) {
+    const { params, query } = request;
+    // Fetch data however you like (Database, internal service, etc.)
+    return {
+      username: `User #${params.id}`,
+      debug: { query }
+    };
+  }
+</script>
+
+<h1>{data.username}</h1>
+```
+
+The `request` object passed to `load()` (alias: `RequestData`) contains:
+
+| Property | Description |
+|----------|-------------|
+| `url`    | Full request URL. |
+| `params` | Dynamic route params parsed from the URL. |
+| `query`  | Query-string parameters. |
+| `headers`| Raw request headers. |
+| `body`   | Parsed request body (for POST/PUT …). |
+| `context`| Mutable per-request bag you can populate in middleware. |
+
+## Building for Production
+
+1. **Add build scripts to package.json**:
+
+```json
+"scripts": {
+  "build:client": "vite build",
+  "build:ssr": "SSR=true vite build --ssr",
+  "build": "npm run build:client && npm run build:ssr"
+}
+```
+
+2. **Run build**:
+
+```bash
+npm run build
+```
+
+3. **Start production server**:
+
+```bash
+NODE_ENV=production node server.js
+```
+
+## Testing with Vitest / Jest
+
+When you test Forge apps with **Vitest** or **Jest** you usually drive the
+Express server via **supertest**:
+
+```ts
+import request from 'supertest';
+import { buildServer } from '../server';
+
+const app = await buildServer();
+
+it('renders the landing page', async () => {
+  const res = await request(app).get('/');
+  expect(res.status).toBe(200);
+  expect(res.text).toContain('<h1>Welcome');
+});
+
+afterAll(() => {
+  if (app.close) app.close();
+});
+```
+
+Two things to remember:
+
+1. The **HTML is streamed**, so the response body is available in `res.text`.
+2. Always close the server after long-running suites to release file & WS handles.
+
+## Troubleshooting
+
+### Common Issues
+
+#### Components Not Loading
+
+Ensure your `component_dir` matches the directory structure and is accessible relative to your project root.
+
+#### SSR Hydration Errors
+
+- Check for components that use browser-specific APIs without checking for `typeof window !== 'undefined'`
+- Ensure components use the same data during SSR and client-side hydration
+
+#### HMR not triggering inside WSL / Docker
+
+File system events can behave differently inside virtualised environments.  If
+you do not see hot-reloading updates, set `watch: { usePolling: true }` in
+`vite.config.js`.  This project’s config already enables it – the note is here
+so you know *why*.
+
+#### "Unexpected token <" / Hydration mismatch warnings
+
+Usually indicates that the HTML the server sent does not match the DOM the
+client tries to hydrate.  Double-check that any data returned from a
+component’s `load()` function is identical on **both** sides.
+
+#### Route Not Found
+
+- Verify your OpenAPI paths are correctly defined
+- Check that component file paths in `x-view` and `x-layout` are correct
+- Ensure all referenced components exist
+
+## Stitch Integration (Modular YAML)
+
+Forge automatically detects and builds stitch configurations for modular OpenAPI development. Instead of maintaining a single large `openapi.yaml`, you can split your API specification into multiple files.
+
+### Using Stitch Files
+
+1. **Create a stitch configuration** (`stitch.yaml`):
+
+```yaml
+stitch:
+  - openapi/base.yaml
+  - openapi/routes/*.yaml
+  - openapi/components/*.yaml
+```
+
+2. **Pre-load YAML modules** in your client application:
+
+```typescript
+// Client-side: Load YAML files into Vite's module cache
+const yamlFiles = import.meta.glob('./openapi/**/*.yaml', { query: '?raw', import: 'default', eager: true });
+
+await createApp(document.getElementById('app'), {
+  open_api_path: 'frontend/stitch.yaml',  // Framework auto-detects and builds
+  component_dir: 'frontend/components/views'
+});
+```
+
+3. **Framework auto-detection** – Forge automatically:
+   - Detects stitch files by checking for the `stitch` root property
+   - Builds the final OpenAPI configuration using `@noego/stitch/browser`
+   - Uses the cached YAML modules from your `import.meta.glob` call
+   - Falls back to regular OpenAPI processing for non-stitch files
+
+### Benefits
+
+- **No manual build steps** – No need for `npm run stitch:frontend`
+- **Modular development** – Split complex APIs into focused files
+- **Hot reloading** – Vite automatically reloads when YAML files change
+- **Backwards compatible** – Existing `openapi.yaml` files work unchanged
+
+### Requirements
+
+- Client applications must call `import.meta.glob('./openapi/**/*.yaml', ...)` for Vite caching
+- The glob pattern must be **static** and **top-level** for Vite's static analysis
+- YAML files are loaded into the browser bundle but only once (no duplication)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+ISC

package/dist/client/client.d.ts

@@ -0,0 +1,8 @@
+import { ServerOptions } from '../options/ServerOptions';
+import { FetchMiddlewareAPI } from '../types/FetchMiddleware';
+export declare const FORGE_LOAD_SYMBOL: unique symbol;
+export declare const fetch: FetchMiddlewareAPI & {
+    getMiddlewareCount(): number;
+};
+export declare function createApp<T extends HTMLElement = HTMLElement>(node: T, options: ServerOptions): Promise<void>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client/client.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,KAAK,EAAmB,kBAAkB,EAAsD,MAAM,0BAA0B,CAAC;AAGxI,eAAO,MAAM,iBAAiB,eAAgC,CAAC;AA4F/D,eAAO,MAAM,KAAK,EAAE,kBAAkB,GAAG;IAAE,kBAAkB,IAAI,MAAM,CAAA;CAwBtE,CAAC;AAIF,wBAAsB,SAAS,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC/D,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,aAAa,GACvB,OAAO,CAAC,IAAI,CAAC,CAkCf"}

package/dist/client/events.d.ts

@@ -0,0 +1,4 @@
+import { IRoute } from '../parser/IRoute';
+import { UrlMatcher } from '../routing/url_parser';
+export declare function bootstrap_events(base_path: string, routes: IRoute[], matchers: UrlMatcher[]): void;
+//# sourceMappingURL=events.d.ts.map

package/dist/client/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/client/events.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAQxD,wBAAgB,gBAAgB,CAAC,SAAS,EAAC,MAAM,EAAC,MAAM,EAAC,MAAM,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,QA+JxF"}

package/dist/client/index.d.ts

@@ -0,0 +1,6 @@
+export { createApp, fetch } from './client';
+export { loadRoute, updateRoute } from './navigation.svelte';
+export { bootstrap_events } from './events';
+export { updateManifestStore, MANIFEST_STORE } from '../routing/manifest/store.svelte';
+export { page, shadowUrl } from './page.svelte';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvF,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC"}

package/dist/client/navigation.svelte.d.ts

@@ -0,0 +1,4 @@
+import { IRoute } from '../parser/IRoute';
+export declare function loadRoute(node: any, base_path: string, route: IRoute, combinedParams: any, urlParams: any, query: any): Promise<void>;
+export declare function updateRoute(url: string, base_path: string, route: IRoute, params: any, urlParams: any, query: any, server_loading?: boolean, update?: boolean): Promise<void>;
+//# sourceMappingURL=navigation.svelte.d.ts.map

package/dist/client/navigation.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.svelte.d.ts","sourceRoot":"","sources":["../../src/client/navigation.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAiC9C,wBAAsB,SAAS,CAAC,IAAI,EAAC,GAAG,EAAC,SAAS,EAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,EAAE,SAAS,EAAC,GAAG,EAAE,KAAK,EAAC,GAAG,iBAwCtH;AAID,wBAAsB,WAAW,CAAC,GAAG,EAAC,MAAM,EAAC,SAAS,EAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAC,SAAS,EAAC,GAAG,EAAC,KAAK,EAAC,GAAG,EAAC,cAAc,GAAC,OAAe,EAAC,MAAM,UAAO,iBAgE7J"}

package/dist/client/page.svelte.d.ts

@@ -0,0 +1,4 @@
+import { IPage } from '../routing/page';
+export declare let page: IPage;
+export declare function shadowUrl(pattern: string, url: string): any;
+//# sourceMappingURL=page.svelte.d.ts.map

package/dist/client/page.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page.svelte.d.ts","sourceRoot":"","sources":["../../src/client/page.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAM7C,eAAO,IAAI,IAAI,OAKJ,CAAC;AAYZ,wBAAgB,SAAS,CAAC,OAAO,EAAC,MAAM,EAAE,GAAG,EAAE,MAAM,OAUpD"}