tungsten 0.3.1 → 0.3.3

package/dist/hydrate/renderHydrationMismatchBanner.js

@@ -0,0 +1,69 @@
+// Read by the CSS rule below via attr() - not by Tungsten. Exported so an
+// application that wants different styling can target the same selector.
+export const hydrationMismatchAttribute = 'data-tungsten-hydration-mismatches';
+const styleId = 'tungsten-hydration-mismatches-style';
+// Reports hydration mismatches in the page, not only the console, without
+// adding a real DOM node to the hydrated tree.
+//
+// A real element - even one appended after hydration finishes and never
+// touched again by this code - is not actually safe here. Every container
+// Tungsten re-renders gets a fresh `new DomRegion(containerDomNode)` built
+// from whatever is *actually* in its childNodes at that moment, and every
+// position Tungsten writes to next is a raw index into that same list
+// (DomPointer.get/next/prev, and several inline `childNodes[domPointer.index]`
+// reads in integrateUpdateVdom.ts/hydrate.tsx). An extra, untracked child
+// shifts every index after it, so the next update touching that container
+// - body, in a typical app - would compare and write to the wrong nodes.
+// There is no flag on an element that makes the walker skip it; it would
+// have to be built into DomPointer/DomRegion and every direct childNodes
+// access alongside them, which is a core-framework change, not a banner.
+//
+// Attributes are a different story: reconcileHydratedAttributes only runs
+// once, during hydration, before this ever runs, and every later update
+// (updateAttributes) diffs against domNode.__tungsten_oldAttributes - its
+// own private record of what it last set - never the DOM's live attribute
+// list. A plain setAttribute() here is in neither its old props nor its new
+// props, so it is never visited, and never removed.
+//
+// So: set an attribute on <html> (outside Tungsten's own bookkeeping, so
+// permanently untouched by it) and let a `content: attr(...)` pseudo-element
+// display it. A pseudo-element is not a real node - never in .childNodes,
+// never visited by DomPointer or DomRegion - so this carries zero index risk
+// for the app's own reconciliation, at the cost of one small, deliberately
+// hacky wrinkle: a single <style> tag inserted into <head> once.
+//
+// head is not structurally exempt from diffing in general - it currently
+// just never gets diffed node-by-node during hydration (hydrateNodeSingle's
+// 'head' case skips it outright, a known hack, not a guarantee), and nothing
+// in a typical app changes head's vdom children after mount, so the general
+// update path never exercises it either. That could change. What head does
+// already have is a marker for exactly this situation - data--t-persist,
+// used by processHead.ts for framework-injected head content (the entry
+// script, the component CSS link) that isn't part of the app's own vdom and
+// must survive hydration - so this style tag carries it too, rather than
+// riding on the blanket skip alone.
+export function renderHydrationMismatchBanner(mismatches, doc = document) {
+  if (mismatches.length === 0) return;
+  if (doc.getElementById(styleId) === null) {
+    const style = doc.createElement('style');
+    style.id = styleId;
+    style.setAttribute('data--t-persist', 'true');
+    style.textContent = `
+            html[${hydrationMismatchAttribute}]::before {
+                content: attr(${hydrationMismatchAttribute});
+                display: block;
+                background: #7a1f1f;
+                color: #fff;
+                font: 13px/1.5 monospace;
+                padding: 8px 12px;
+                max-height: 33vh;
+                overflow: auto;
+                white-space: pre-wrap;
+            }
+        `;
+    doc.head.appendChild(style);
+  }
+  const heading = `Tungsten: ${mismatches.length} hydration mismatch${mismatches.length === 1 ? '' : 'es'} (dev only)`;
+  const lines = mismatches.map(mismatch => `<${mismatch.tagName}> ${mismatch.name}: ` + `rendered ${JSON.stringify(mismatch.expected)}, server sent ${JSON.stringify(mismatch.actual)}`);
+  doc.documentElement.setAttribute(hydrationMismatchAttribute, [heading, ...lines].join('\n'));
+}

package/dist/importDevModuleWithRetry.d.ts

@@ -0,0 +1,3 @@
+export declare function isTransientDevModuleError(e: unknown): boolean;
+export declare function importDevModuleWithRetry(url: string, attempts?: number, delayMs?: number): Promise<any>;
+//# sourceMappingURL=importDevModuleWithRetry.d.ts.map

package/dist/importDevModuleWithRetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importDevModuleWithRetry.d.ts","sourceRoot":"","sources":["../src/importDevModuleWithRetry.ts"],"names":[],"mappings":"AAuBA,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAU7D;AAMD,wBAAsB,wBAAwB,CAC1C,GAAG,EAAE,MAAM,EACX,QAAQ,SAAK,EACb,OAAO,SAAM,GACd,OAAO,CAAC,GAAG,CAAC,CAUd"}

package/dist/importDevModuleWithRetry.js

@@ -0,0 +1,46 @@
+// importDevModuleWithRetry
+// exports importDevModuleWithRetry (function)
+//
+// Dev-mode dynamic import wrapper. tsc's own --watch mode emits a multi-file
+// edit (e.g. a rename spanning two files) one recompiled file at a time, so
+// there's a real window where one file has landed and the other hasn't yet.
+// A dev-server request for a component in that window hits a genuine (but
+// self-resolving within a few hundred ms) module-shape error - without this,
+// that's a scary SSR error page for what is, from the developer's
+// perspective, a completely normal edit. Retrying a few times with a fresh
+// cache-busting query per attempt rides out the window; a real, permanent
+// error still surfaces (just slightly slower) once attempts are exhausted.
+// A two-file edit's compile cycle runs tsc's incremental emit followed by a
+// separate downstream babel recompile, sequentially - observed live to take
+// several seconds under load, so the default budget below is generous rather
+// than tuned to a happy-path guess. There's no precise "compile cycle
+// finished" signal plumbed through to here to await instead; this is a
+// bounded heuristic, not a proper synchronization fix.
+// Exported so other dev-only tools (the error page's auto-retry script - see
+// devErrorPageAutoRetry.ts) can recognize the same transient shape without
+// duplicating the heuristic.
+export function isTransientDevModuleError(e) {
+  if (!(e instanceof Error)) return false;
+  if (e.code === 'ERR_MODULE_NOT_FOUND') return true;
+  if (/does not provide an export named/.test(e.message)) return true;
+  // A within-file version of the same race: a multi-step edit can transiently save a file
+  // whose import line was updated but whose JSX/body still references the old local name -
+  // that's a plain runtime ReferenceError, not an ESM linking error, but self-resolves the same
+  // way once the file's own recompile catches up. Kept narrow (a bare identifier only) so it
+  // doesn't swallow other ReferenceError shapes that are more likely to be genuine bugs.
+  return e instanceof ReferenceError && /^\w+ is not defined$/.test(e.message);
+}
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+export async function importDevModuleWithRetry(url, attempts = 30, delayMs = 250) {
+  for (let attempt = 0;; attempt++) {
+    try {
+      const attemptUrl = attempt === 0 ? url : `${url}${url.includes('?') ? '&' : '?'}retryAttempt=${attempt}`;
+      return await import(attemptUrl); // eslint-disable-line @typescript-eslint/no-unsafe-return
+    } catch (e) {
+      if (attempt >= attempts - 1 || !isTransientDevModuleError(e)) throw e;
+      await delay(delayMs);
+    }
+  }
+}

package/dist/indexInner.d.ts

@@ -16,13 +16,18 @@ export * from './components/bindable/BindableTextarea.jsx';
 export * from './components/GoToComponent.jsx';
 export * from './components/Lazy.js';
 export * from './components/Link.jsx';
+export * from './components/PopMessages.jsx';
 export * from './components/RawHtml.jsx';
 export * from './components/RouteRedirectComponent.jsx';
 export { parseHtml, type ParseHtmlOptions } from './rawHtml/parseHtml.js';
 export { safeHtmlAllowList } from './rawHtml/safeHtmlAllowList.js';
 export type { HtmlAllowList } from './rawHtml/HtmlAllowList.js';
+export { sanitizeHtml, type SanitizeHtmlOptions } from './rawHtml/sanitizeHtml.js';
+export { filterContentNode } from './rawHtml/filterContentNode.js';
+export { contentNodeToHtml } from './render/contentNodeToHtml.js';
 export * from './components/WebRedirectComponent.jsx';
 export * from './nbsp.js';
+export { pop, dismissPop } from './pop.js';
 export * from './browserStorage.js';
 export { createElement } from './createElement.js';
 export * from './createRef.js';
@@ -64,12 +69,15 @@ export * from './ContentNode.js';
 export type { GenericObject } from './GenericObject.type.js';
 export type { Instance } from './Instance/Instance.js';
 export type { Key } from './Key.js';
+export type { PopMessage } from './PopMessage.type.js';
 export type { ReqRes, ReqResOrNull } from './ReqRes.js';
 export type { Params } from './routing/Params.js';
 export type { ParamsFromPath } from './routing/ParamsFromPath.js';
 export type { RouteType, Route } from './routing/RouteType.js';
 export { type RouteKey, type Path, type Path as RoutePath, StringIsPath, RouteKeyIsPath } from './routing/RouteTypes.js';
 export type { Routes, CustomRoutes } from './routing/Routes.js';
+export type { ErrorRouteType } from './routing/ErrorRouteType.js';
+export { type TungstenErrorInfo, makeTungstenErrorInfo } from './routing/TungstenErrorInfo.js';
 export type { RouteParams } from './routing/RouteParams.type.js';
 export type { RouteData } from './routing/RouteData.js';
 export type { RouteDataFunction } from './routing/RouteDataFunction.type.js';

package/dist/indexInner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"indexInner.d.ts","sourceRoot":"","sources":["../src/indexInner.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"indexInner.d.ts","sourceRoot":"","sources":["../src/indexInner.ts"],"names":[],"mappings":"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"}

package/dist/indexInner.js

@@ -21,12 +21,17 @@ export * from "./components/bindable/BindableTextarea.js";
 export * from "./components/GoToComponent.js";
 export * from "./components/Lazy.js";
 export * from "./components/Link.js";
+export * from "./components/PopMessages.js";
 export * from "./components/RawHtml.js";
 export * from "./components/RouteRedirectComponent.js";
 export { parseHtml } from "./rawHtml/parseHtml.js";
 export { safeHtmlAllowList } from "./rawHtml/safeHtmlAllowList.js";
+export { sanitizeHtml } from "./rawHtml/sanitizeHtml.js";
+export { filterContentNode } from "./rawHtml/filterContentNode.js";
+export { contentNodeToHtml } from "./render/contentNodeToHtml.js";
 export * from "./components/WebRedirectComponent.js";
 export * from "./nbsp.js";
+export { pop, dismissPop } from "./pop.js";
 export * from "./browserStorage.js";
 export { createElement } from "./createElement.js";
 export * from "./createRef.js";
@@ -66,4 +71,5 @@ export * from "./components/Stylesheet.js";
 export { TungstenError } from "./TungstenError.js";
 export * from "./__deproxy.js";
 export * from "./ContentNode.js"; // types and type guards
-export { StringIsPath, RouteKeyIsPath } from "./routing/RouteTypes.js";
+export { StringIsPath, RouteKeyIsPath } from "./routing/RouteTypes.js";
+export { makeTungstenErrorInfo } from "./routing/TungstenErrorInfo.js";

package/dist/makeInstanceConfigFromFrameworkConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"makeInstanceConfigFromFrameworkConfig.d.ts","sourceRoot":"","sources":["../src/makeInstanceConfigFromFrameworkConfig.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAEnE,wBAAgB,qCAAqC,CACjD,eAAe,EAAE,uBAAuB,EAAE,GAAG,GAAE,OAAe,GAC/D,cAAc,CAUhB"}
+{"version":3,"file":"makeInstanceConfigFromFrameworkConfig.d.ts","sourceRoot":"","sources":["../src/makeInstanceConfigFromFrameworkConfig.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAA;AAClE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAA;AAEnE,wBAAgB,qCAAqC,CACjD,eAAe,EAAE,uBAAuB,EAAE,GAAG,GAAE,OAAe,GAC/D,cAAc,CAWhB"}

package/dist/makeInstanceConfigFromFrameworkConfig.js

@@ -5,7 +5,8 @@ export function makeInstanceConfigFromFrameworkConfig(frameworkConfig, dev = fal
     useRootComponent: frameworkConfig.useRootComponent,
     clientSideNav: frameworkConfig.clientSideNav,
     siteBasePath: dev ? '' : frameworkConfig.siteBasePath,
-    staticSite: frameworkConfig.staticSite
+    staticSite: frameworkConfig.staticSite,
+    csr: frameworkConfig.csr
   };
   if ('sourceDir' in frameworkConfig) c.sourceDir = frameworkConfig.sourceDir;
   return c;

package/dist/pop.d.ts

@@ -0,0 +1,10 @@
+import type { Instance } from './Instance/Instance.js';
+export declare function registerPopInstance(newInstance: Instance): void;
+export declare function dismissPop(id: number): void;
+export declare function pop(text: string): void;
+type PopFunction = typeof pop;
+declare global {
+    var pop: PopFunction;
+}
+export {};
+//# sourceMappingURL=pop.d.ts.map

package/dist/pop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pop.d.ts","sourceRoot":"","sources":["../src/pop.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAStD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,QAAQ,GAAG,IAAI,CAE/D;AAQD,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAO3C;AAID,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAatC;AAMD,KAAK,WAAW,GAAG,OAAO,GAAG,CAAA;AAE7B,OAAO,CAAC,MAAM,CAAC;IAEX,IAAI,GAAG,EAAE,WAAW,CAAA;CACvB"}

package/dist/pop.js

@@ -0,0 +1,49 @@
+import { isServer } from "./isServer.js";
+import { log, warn } from "./appOutput.js";
+// Set once by PopMessages.clientInit, from this.__instance - one Instance per app, shared
+// across the whole client lifetime, so no per-component proxy/subscription is needed here.
+let instance = null;
+export function registerPopInstance(newInstance) {
+  instance = newInstance;
+}
+let nextId = 0;
+const AUTO_DISMISS_MS = 3000;
+const LEAVE_MS = 200; // match .pop-message.leaving's transition duration in PopMessages.tsx
+// Shared by pop()'s auto-dismiss and PopMessages' click-to-dismiss, so both leave the same way.
+export function dismissPop(id) {
+  if (instance === null) return;
+  const {
+    popMessages
+  } = instance.internalStore;
+  popMessages.set(popMessages.get().map(message => message.id === id ? {
+    ...message,
+    leaving: true
+  } : message));
+  setTimeout(() => {
+    popMessages.set(popMessages.get().filter(message => message.id !== id));
+  }, LEAVE_MS);
+}
+// Shows a dismissible banner via <PopMessages/> (an app mounts one in its Root). Also available
+// as global.pop / window.pop for ad-hoc use outside component code, on server and client alike.
+export function pop(text) {
+  if (isServer) {
+    log('pop: ' + text);
+    return;
+  }
+  if (instance === null) {
+    warn('pop() called before the app finished mounting; message dropped:', text);
+    return;
+  }
+  const message = {
+    id: nextId++,
+    text
+  };
+  const {
+    popMessages
+  } = instance.internalStore;
+  popMessages.set([...popMessages.get(), message]);
+  setTimeout(() => dismissPop(message.id), AUTO_DISMISS_MS);
+}
+// Assigned at module load in both environments, so a pre-mount browser call hits pop()'s
+// no-bridge branch instead of throwing.
+globalThis.pop = pop;

package/dist/rawHtml/filterContentNode.d.ts

@@ -0,0 +1,20 @@
+import type { ContentNode } from '../ContentNode.js';
+import type { HtmlAllowList } from './HtmlAllowList.js';
+/**
+ * Applies an allow list to a content tree that already exists, rather than
+ * one being built - the same decisions `parseHtml(html, { allowList })` makes
+ * while parsing, for a tree that did not come from parsing HTML at all (one
+ * rebuilt from storage, for instance) and so never had the chance to.
+ *
+ * A disallowed element is unwrapped, keeping its children in its place, so
+ * filtering a tag never costs the reader the words inside it - the same rule
+ * `parseHtml` applies. An element holding program text rather than prose
+ * (`<script>`, and anything on the same footing as `<script>` even under a
+ * permissive allow list) is dropped whole instead. `on*` props, `ref`, and
+ * `dangerouslySetInnerHTML` are always stripped - the tree-shape equivalent
+ * of what `parseHtml` refuses to produce in the first place - and a `href`/
+ * `src`/... value using an executable scheme (`javascript:`, `vbscript:`) or,
+ * on a navigating attribute, `data:` is dropped the same way.
+ */
+export declare function filterContentNode(node: ContentNode, allowList: HtmlAllowList): ContentNode;
+//# sourceMappingURL=filterContentNode.d.ts.map

package/dist/rawHtml/filterContentNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterContentNode.d.ts","sourceRoot":"","sources":["../../src/rawHtml/filterContentNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAa,MAAM,mBAAmB,CAAA;AAI/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAyFvD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,GAAG,WAAW,CAE1F"}

package/dist/rawHtml/filterContentNode.js

@@ -0,0 +1,96 @@
+import { ContentNodeIsComponent } from "../ContentNode.js";
+import { $props, $type } from "../contentNodeSymbols.js";
+import { StringIsHtmlEvent } from "../htmlEvents.js";
+import { blockedUrl, makeAllowCheck, removalFor, urlAttributes } from "./parseHtml.js";
+// The NodeProps equivalent of parseHtml's class->className, style->css
+// rename: the allow list is written in terms of the HTML attribute name, but
+// a content tree already carries Tungsten's prop names for these two.
+const attributeCheckName = {
+  className: 'class',
+  css: 'style'
+};
+function filterProps(tag, props, allow) {
+  const filtered = {};
+  for (const key in props) {
+    if (key === 'children') continue;
+    const value = props[key];
+    // Tungsten reads these as event listeners, not attributes - same rule
+    // parseHtml applies to on* HTML attributes, expressed for prop names.
+    if (StringIsHtmlEvent(key)) continue;
+    // Raw markup that bypasses tree filtering entirely: parseHtml never
+    // produces this prop, so a tree in its shape should not carry it either.
+    if (key === 'dangerouslySetInnerHTML') continue;
+    if (key === 'ref') continue;
+    const checkName = (attributeCheckName[key] ?? key).toLowerCase();
+    if (!allow.attribute(tag, checkName)) continue;
+    if (checkName in urlAttributes && typeof value === 'string' && blockedUrl(checkName, value)) continue;
+    filtered[key] = value;
+  }
+  return filtered;
+}
+// Matches toContentNode() in parseHtml.ts: zero children omits the prop,
+// one is the value directly (not wrapped in an array), two or more is an
+// array. Without this, an element that loses every child to filtering ends
+// up with an empty-array `children` instead of no `children` prop at all -
+// a shape parseHtml itself would never produce.
+function normalizeChildren(children) {
+  if (!Array.isArray(children)) return children;
+  if (children.length === 0) return null;
+  if (children.length === 1) return children[0] ?? null;
+  return children;
+}
+function filter(node, allow) {
+  if (node === undefined || node === null || node === true || node === false) return node;
+  if (typeof node === 'string' || typeof node === 'number') return node;
+  if (Array.isArray(node)) {
+    const out = [];
+    for (const child of node) {
+      const filteredChild = filter(child, allow);
+      // Non-rendered values, whether the child already was one or
+      // filtering made it one (an unwrapped or dropped element that
+      // left nothing behind), contribute nothing to the array - never
+      // a stray null placeholder in a dropped element's place.
+      if (filteredChild === undefined || filteredChild === null || filteredChild === true || filteredChild === false) continue;
+      if (Array.isArray(filteredChild)) out.push(...filteredChild);else out.push(filteredChild);
+    }
+    return out;
+  }
+  // Not authored markup - parseHtml never produces a component node, so a
+  // tree in its shape should not carry one either, but this is defensive
+  // rather than reachable: nothing that round-trips through storage (JSON)
+  // can carry a class or function reference.
+  if (ContentNodeIsComponent(node)) return node;
+  const tag = node[$type];
+  const removal = removalFor(tag, true, allow);
+  if (removal === 'drop') return null;
+  const children = normalizeChildren(filter(node[$props].children ?? null, allow));
+  if (removal === 'unwrap') return children ?? [];
+  return {
+    [$type]: tag,
+    [$props]: {
+      ...filterProps(tag, node[$props], allow),
+      ...(children === null ? {} : {
+        children
+      })
+    }
+  };
+}
+/**
+ * Applies an allow list to a content tree that already exists, rather than
+ * one being built - the same decisions `parseHtml(html, { allowList })` makes
+ * while parsing, for a tree that did not come from parsing HTML at all (one
+ * rebuilt from storage, for instance) and so never had the chance to.
+ *
+ * A disallowed element is unwrapped, keeping its children in its place, so
+ * filtering a tag never costs the reader the words inside it - the same rule
+ * `parseHtml` applies. An element holding program text rather than prose
+ * (`<script>`, and anything on the same footing as `<script>` even under a
+ * permissive allow list) is dropped whole instead. `on*` props, `ref`, and
+ * `dangerouslySetInnerHTML` are always stripped - the tree-shape equivalent
+ * of what `parseHtml` refuses to produce in the first place - and a `href`/
+ * `src`/... value using an executable scheme (`javascript:`, `vbscript:`) or,
+ * on a navigating attribute, `data:` is dropped the same way.
+ */
+export function filterContentNode(node, allowList) {
+  return filter(node, makeAllowCheck(allowList));
+}

package/dist/rawHtml/parseHtml.d.ts

@@ -18,6 +18,20 @@ export type ParseHtmlOptions = {
      */
     allowList?: HtmlAllowList | undefined;
 };
+export type AllowCheck = {
+    tag: (name: string) => boolean;
+    attribute: (tag: string, name: string) => boolean;
+};
+export declare function makeAllowCheck(allowList: HtmlAllowList | undefined): AllowCheck;
+export declare const urlAttributes: Record<string, true>;
+export declare function blockedUrl(attributeName: string, value: string): boolean;
+/**
+ * Whether an element survives, and if not, how it goes.
+ *
+ * Elements holding program text rather than prose are dropped whole — there is
+ * no reader's content inside them to preserve. Everything else is unwrapped.
+ */
+export declare function removalFor(name: string, sanitize: boolean, allow: AllowCheck): 'drop' | 'unwrap' | undefined;
 /**
  * Parses raw HTML into a Tungsten content tree.
  *

package/dist/rawHtml/parseHtml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseHtml.d.ts","sourceRoot":"","sources":["../../src/rawHtml/parseHtml.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,mBAAmB,CAAA;AAKhF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,MAAM,MAAM,gBAAgB,GAAG;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC9B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CACxC,CAAA;AAsID;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,WAAW,CAqGnF"}
+{"version":3,"file":"parseHtml.d.ts","sourceRoot":"","sources":["../../src/rawHtml/parseHtml.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAA8B,MAAM,mBAAmB,CAAA;AAKhF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAEvD,MAAM,MAAM,gBAAgB,GAAG;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC9B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,aAAa,GAAG,SAAS,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACrB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;IAC9B,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CACpD,CAAA;AAID,wBAAgB,cAAc,CAAC,SAAS,EAAE,aAAa,GAAG,SAAS,GAAG,UAAU,CAe/E;AAiBD,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAE9C,CAAA;AA2BD,wBAAgB,UAAU,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAOxE;AAgCD;;;;;GAKG;AACH,wBAAgB,UAAU,CACtB,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,GACnD,MAAM,GAAG,QAAQ,GAAG,SAAS,CAK/B;AAYD;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,gBAAqB,GAAG,WAAW,CAqGnF"}

package/dist/rawHtml/parseHtml.js

@@ -6,7 +6,7 @@ const allowEverything = {
   tag: () => true,
   attribute: () => true
 };
-function makeAllowCheck(allowList) {
+export function makeAllowCheck(allowList) {
   if (allowList === undefined) return allowEverything;
   const tags = new Set(allowList.tags);
   const attributes = new Set(allowList.attributes);
@@ -21,7 +21,7 @@ function makeAllowCheck(allowList) {
 }
 // REGEX: on followed by at least one letter, e.g. onclick, onerror
 const eventAttribute = /^on[a-z]/i;
-const urlAttributes = {
+export const urlAttributes = {
   href: true,
   src: true,
   action: true,
@@ -56,7 +56,7 @@ function urlScheme(url) {
   }
   return '';
 }
-function blockedUrl(attributeName, value) {
+export function blockedUrl(attributeName, value) {
   const scheme = urlScheme(value);
   if (scheme in executableSchemes) return true;
   // data: URLs can carry a whole HTML document, so they are barred from
@@ -87,7 +87,7 @@ function attributesToProps(tag, attributes, sanitize, allow) {
  * Elements holding program text rather than prose are dropped whole — there is
  * no reader's content inside them to preserve. Everything else is unwrapped.
  */
-function removalFor(name, sanitize, allow) {
+export function removalFor(name, sanitize, allow) {
   if (sanitize && name === 'script') return 'drop';
   if (allow.tag(name)) return undefined;
   return name in htmlRawTextTags ? 'drop' : 'unwrap';

package/dist/rawHtml/sanitizeHtml.d.ts

@@ -0,0 +1,17 @@
+import type { HtmlAllowList } from './HtmlAllowList.js';
+export type SanitizeHtmlOptions = {
+    /** Defaults to `safeHtmlAllowList`. Pass your own list to allow more or less. */
+    allowList?: HtmlAllowList;
+};
+/**
+ * Cleans untrusted HTML and returns it as a string, synchronously.
+ *
+ * `parseHtml()` already does the cleaning - this only adds the return trip,
+ * for a caller that needs the result as a string rather than a content tree:
+ * a paste handler cleaning a clipboard payload before it is inserted, or an
+ * editor cleaning its content before it is stored. Both happen at a rate
+ * `renderingNodeToHtml` (the async, component-aware server renderer) is the
+ * wrong shape for.
+ */
+export declare function sanitizeHtml(html: string, options?: SanitizeHtmlOptions): string;
+//# sourceMappingURL=sanitizeHtml.d.ts.map

package/dist/rawHtml/sanitizeHtml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeHtml.d.ts","sourceRoot":"","sources":["../../src/rawHtml/sanitizeHtml.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAIvD,MAAM,MAAM,mBAAmB,GAAG;IAC9B,iFAAiF;IACjF,SAAS,CAAC,EAAE,aAAa,CAAA;CAC5B,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,MAAM,CAGpF"}

package/dist/rawHtml/sanitizeHtml.js

@@ -0,0 +1,19 @@
+import { contentNodeToHtml } from "../render/contentNodeToHtml.js";
+import { parseHtml } from "./parseHtml.js";
+import { safeHtmlAllowList } from "./safeHtmlAllowList.js";
+/**
+ * Cleans untrusted HTML and returns it as a string, synchronously.
+ *
+ * `parseHtml()` already does the cleaning - this only adds the return trip,
+ * for a caller that needs the result as a string rather than a content tree:
+ * a paste handler cleaning a clipboard payload before it is inserted, or an
+ * editor cleaning its content before it is stored. Both happen at a rate
+ * `renderingNodeToHtml` (the async, component-aware server renderer) is the
+ * wrong shape for.
+ */
+export function sanitizeHtml(html, options = {}) {
+  const allowList = options.allowList ?? safeHtmlAllowList;
+  return contentNodeToHtml(parseHtml(html, {
+    allowList
+  }));
+}

package/dist/render/HeadData.d.ts

@@ -11,5 +11,7 @@ export type HeadData = {
     dev: boolean;
     tungstenPublicEnv: TungstenEnvOrUndefined;
     siteBasePath: SiteBasePath;
+    hmr: boolean | 'reload';
+    csr: boolean;
 };
 //# sourceMappingURL=HeadData.d.ts.map

package/dist/render/HeadData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeadData.d.ts","sourceRoot":"","sources":["../../src/render/HeadData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE9D,MAAM,MAAM,YAAY,GAAG,EAAE,GAAG,IAAI,MAAM,EAAE,CAAA;AAE5C,MAAM,MAAM,QAAQ,GAAG;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,mBAAmB,EAAE,aAAa,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,YAAY,EAAE,YAAY,CAAA;CAC7B,CAAA"}
+{"version":3,"file":"HeadData.d.ts","sourceRoot":"","sources":["../../src/render/HeadData.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAE9D,MAAM,MAAM,YAAY,GAAG,EAAE,GAAG,IAAI,MAAM,EAAE,CAAA;AAE5C,MAAM,MAAM,QAAQ,GAAG;IACnB,KAAK,EAAE,OAAO,CAAA;IACd,QAAQ,EAAE,QAAQ,CAAC;IACnB,mBAAmB,EAAE,aAAa,CAAC;IACnC,aAAa,EAAE,aAAa,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,iBAAiB,EAAE,sBAAsB,CAAC;IAC1C,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,EAAE,OAAO,GAAG,QAAQ,CAAA;IACvB,GAAG,EAAE,OAAO,CAAA;CACf,CAAA"}

package/dist/render/contentNodeToHtml.d.ts

@@ -0,0 +1,18 @@
+import type { ContentNode } from '../ContentNode.js';
+/**
+ * Serialises a content tree to HTML, synchronously.
+ *
+ * `renderingNodeToHtml` (the server's real renderer) covers the general case -
+ * components, async data, `<head>` - and is async and internal because of it.
+ * This covers the subset that never needs any of that: plain HTML elements,
+ * text and arrays, the exact shape `parseHtml()` produces. Given a component
+ * node it throws rather than silently rendering nothing, since a caller
+ * reaching for the synchronous path has nothing that could resolve one.
+ *
+ * Attribute values are escaped, unlike `renderingNodeToHtml`'s - that renderer
+ * trusts values from application-authored JSX; this one exists specifically to
+ * round-trip untrusted markup back out as a string, so a value carrying `"`
+ * must not be able to break out of its attribute.
+ */
+export declare function contentNodeToHtml(node: ContentNode): string;
+//# sourceMappingURL=contentNodeToHtml.d.ts.map

package/dist/render/contentNodeToHtml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentNodeToHtml.d.ts","sourceRoot":"","sources":["../../src/render/contentNodeToHtml.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAapD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CA+C3D"}

package/dist/render/contentNodeToHtml.js

@@ -0,0 +1,66 @@
+import { ContentNodeIsComponent } from "../ContentNode.js";
+import { booleanAttributeValue } from "../booleanAttributeValue.js";
+import { $props, $type } from "../contentNodeSymbols.js";
+import { htmlEntities } from "../htmlEntities.js";
+import { innerHtmlFromProps } from "../innerHtmlFromProps.js";
+import { throwError } from "../throwError.js";
+import { validChildren } from "../validChildren.js";
+import { htmlMonoTags } from "./htmlMonoTags.js";
+import { htmlSelfClosableTags } from "./htmlSelfClosableTags.js";
+import { htmlVoidTags } from "./htmlVoidTags.js";
+import { processProps } from "./processProps.js";
+/**
+ * Serialises a content tree to HTML, synchronously.
+ *
+ * `renderingNodeToHtml` (the server's real renderer) covers the general case -
+ * components, async data, `<head>` - and is async and internal because of it.
+ * This covers the subset that never needs any of that: plain HTML elements,
+ * text and arrays, the exact shape `parseHtml()` produces. Given a component
+ * node it throws rather than silently rendering nothing, since a caller
+ * reaching for the synchronous path has nothing that could resolve one.
+ *
+ * Attribute values are escaped, unlike `renderingNodeToHtml`'s - that renderer
+ * trusts values from application-authored JSX; this one exists specifically to
+ * round-trip untrusted markup back out as a string, so a value carrying `"`
+ * must not be able to break out of its attribute.
+ */
+export function contentNodeToHtml(node) {
+  if (node === undefined || node === null || node === false || node === true) return '';
+  if (Array.isArray(node)) return node.map(contentNodeToHtml).join('');
+  if (typeof node === 'string' || typeof node === 'number') return htmlEntities(node.toString());
+  if (ContentNodeIsComponent(node)) {
+    throwError('contentNodeToHtml', `component nodes are not supported - encountered one of type ` + `${String(typeof node[$type] === 'string' ? node[$type] : node[$type].name)}.`);
+  }
+  const type = node[$type];
+  const {
+    children,
+    ...restProps
+  } = node[$props];
+  const attribProps = processProps(restProps);
+  let attributes = '';
+  for (const key in attribProps) {
+    const value = attribProps[key];
+    if (typeof value === 'boolean') {
+      const attrValue = booleanAttributeValue(key, value);
+      if (attrValue !== null) attributes += attrValue === '' ? ` ${key}` : ` ${key}="${attrValue}"`;
+    } else if (value !== undefined && value !== null) {
+      attributes += ` ${key}="${htmlEntities(String(value))}"`;
+    }
+  }
+  const innerHtml = innerHtmlFromProps(type, node[$props], validChildren(children));
+  if (innerHtml !== null) {
+    if (type in htmlVoidTags) {
+      throwError('contentNodeToHtml', `<${type}> is an HTML void type (cannot have children), but the node has dangerouslySetInnerHTML.`);
+    }
+    return `<${type}${attributes}>${innerHtml}</${type}>`;
+  }
+  if (validChildren(children)) {
+    if (type in htmlVoidTags) {
+      throwError('contentNodeToHtml', `<${type}> is an HTML void type (cannot have children), but the node has children.`);
+    }
+    return `<${type}${attributes}>${contentNodeToHtml(children)}</${type}>`;
+  }
+  if (type in htmlMonoTags) return `<${type}${attributes}>`;
+  if (type in htmlSelfClosableTags) return `<${type}${attributes} />`;
+  return `<${type}${attributes}></${type}>`;
+}

package/dist/render/contentToHtml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contentToHtml.d.ts","sourceRoot":"","sources":["../../src/render/contentToHtml.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAY,YAAY,EAAE,MAAM,eAAe,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAMvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAI9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAGrE,wBAAsB,aAAa,CAC/B,eAAe,EAAE,eAAe,EAAE,mBAAmB,EAAE,aAAa,EACpE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EACxC,MAAM,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,YAAY,EACnE,iBAAiB,GAAE,sBAAkC,EAAE,GAAG,UAAQ,GACnE,OAAO,CAAC,MAAM,CAAC,CAoDjB"}
+{"version":3,"file":"contentToHtml.d.ts","sourceRoot":"","sources":["../../src/render/contentToHtml.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAY,YAAY,EAAE,MAAM,eAAe,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAMvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAI9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAA;AAGrE,wBAAsB,aAAa,CAC/B,eAAe,EAAE,eAAe,EAAE,mBAAmB,EAAE,aAAa,EACpE,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EACxC,MAAM,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,YAAY,EACnE,iBAAiB,GAAE,sBAAkC,EAAE,GAAG,UAAQ,GACnE,OAAO,CAAC,MAAM,CAAC,CAsDjB"}