@verajs/ssr 0.1.0
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.
- package/README.md +27 -0
- package/package.json +33 -0
- package/src/vera/index.js +90 -0
- package/src/vera/serializer.js +125 -0
- package/src/vera/shim.js +135 -0
package/README.md
ADDED
|
@@ -0,0 +1,27 @@
|
|
|
1
|
+
# @verajs/ssr
|
|
2
|
+
|
|
3
|
+
Vera-native server-side rendering. Node-only, plain ESM, **zero dependencies** — no wcc, no lit,
|
|
4
|
+
no acorn, no parse5.
|
|
5
|
+
|
|
6
|
+
import { renderToString } from '@verajs/ssr'; // ('/vera' also works)
|
|
7
|
+
const { html, styles } = await renderToString(new URL('./components/app.js', import.meta.url));
|
|
8
|
+
|
|
9
|
+
- Node resolves the component's module graph natively (the `.ts`-via-`.js` convention included);
|
|
10
|
+
execution registers classes through `customElements.define` — no AST walking.
|
|
11
|
+
- Templates flatten through a sigil-aware serializer with per-template-identity plan caching:
|
|
12
|
+
`?bool` resolved by truthiness, `.value`/`.checked`/`.selected` mirrored to attributes,
|
|
13
|
+
`@event`/`&ref` stripped without residue, every interpolated value escaped at the boundary.
|
|
14
|
+
- Output is declarative shadow DOM with **zero framework comments**; light-DOM `@scope` styles are
|
|
15
|
+
returned separately for the page shell.
|
|
16
|
+
- Client-side, `@verajs/renderer/hydrate` adopts the server DOM markerlessly (swap one import).
|
|
17
|
+
- Measured (bench/ssr.mjs, fastest-of-7 rotated): serializer 73 µs / full component pipeline
|
|
18
|
+
107 µs on a 100-row table — ahead of or within 9% of Vue's compiled SSR, 5x lit, 8x React.
|
|
19
|
+
|
|
20
|
+
`examples/ssr-node/server-native.mjs` is a complete server on bare `node:http`.
|
|
21
|
+
|
|
22
|
+
Import `@verajs/ssr` before anything that imports `@verajs/core` — it installs the server
|
|
23
|
+
environment first. Known limits: effects run server-side (guard browser-only work);
|
|
24
|
+
`keyed`/`hold` are client constructs (use plain `.map` in SSR templates).
|
|
25
|
+
|
|
26
|
+
The pre-native strategies (wcc fork, lit-labs renderer, Astro sketch, Reef-era diff renderer)
|
|
27
|
+
are retired; strategy 4 is the only one shipped.
|
package/package.json
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "@verajs/ssr",
|
|
3
|
+
"version": "0.1.0",
|
|
4
|
+
"description": "Vera-native server-side rendering. Node-only, plain ESM, zero dependencies.",
|
|
5
|
+
"license": "MIT",
|
|
6
|
+
"repository": {
|
|
7
|
+
"type": "git",
|
|
8
|
+
"url": "git+https://github.com/vera-js/vera.git",
|
|
9
|
+
"directory": "packages/ssr"
|
|
10
|
+
},
|
|
11
|
+
"author": "VeraJS",
|
|
12
|
+
"homepage": "https://verajs.dev",
|
|
13
|
+
"type": "module",
|
|
14
|
+
"main": "./src/vera/index.js",
|
|
15
|
+
"exports": {
|
|
16
|
+
".": "./src/vera/index.js",
|
|
17
|
+
"./vera": "./src/vera/index.js"
|
|
18
|
+
},
|
|
19
|
+
"files": [
|
|
20
|
+
"src"
|
|
21
|
+
],
|
|
22
|
+
"keywords": [
|
|
23
|
+
"ssr",
|
|
24
|
+
"server side rendering",
|
|
25
|
+
"declarative shadow dom",
|
|
26
|
+
"vera",
|
|
27
|
+
"verajs",
|
|
28
|
+
"web components"
|
|
29
|
+
],
|
|
30
|
+
"publishConfig": {
|
|
31
|
+
"access": "public"
|
|
32
|
+
}
|
|
33
|
+
}
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Vera-native SSR — strategy 4. No wcc, no lit, no acorn, no parse5: Node resolves the module
|
|
3
|
+
* graph (`import()`), execution registers component classes (via `customElements.define`, which
|
|
4
|
+
* the shim owns and core's own wrapper passes through), templates flatten through the
|
|
5
|
+
* sigil-aware serializer, and nested components are discovered by scanning emitted markup for
|
|
6
|
+
* tags the registry knows — never by parsing HTML.
|
|
7
|
+
*
|
|
8
|
+
* Import THIS module before anything that imports `@verajs/core` — the shims must exist before
|
|
9
|
+
* core evaluates (core is dynamically imported below for exactly that reason).
|
|
10
|
+
*
|
|
11
|
+
* Client takeover is a re-render in place (the renderer has no `hydrate()` yet — known TODO);
|
|
12
|
+
* for lit-marker hydration, strategy 2 (`@verajs/ssr`) remains available.
|
|
13
|
+
*/
|
|
14
|
+
import { installShims, registry, hoistedStyles } from './shim.js';
|
|
15
|
+
import { serializeTemplate } from './serializer.js';
|
|
16
|
+
|
|
17
|
+
installShims();
|
|
18
|
+
const { setRenderer } = await import('@verajs/core');
|
|
19
|
+
|
|
20
|
+
/** The server renderer: template object in, markup into the (shadow) container shim. */
|
|
21
|
+
setRenderer((template, container) => {
|
|
22
|
+
container.innerHTML = typeof template === 'string' ? template : serializeTemplate(template);
|
|
23
|
+
});
|
|
24
|
+
|
|
25
|
+
/** Opening tags with a dash — only ones the registry knows get rendered. */
|
|
26
|
+
const CUSTOM_TAG = /<([a-z][\w]*-[\w-]*)((?:\s[^<>]*)?)>/g;
|
|
27
|
+
const ATTRIBUTE = /([\w-]+)(?:="([^"]*)")?/g;
|
|
28
|
+
|
|
29
|
+
const MAX_DEPTH = 32;
|
|
30
|
+
|
|
31
|
+
/**
|
|
32
|
+
* Renders every registered component tag found in `markup` to declarative shadow DOM, spliced in
|
|
33
|
+
* as strings right after each opening tag. Recursion covers components rendered by components.
|
|
34
|
+
*/
|
|
35
|
+
const renderComponentTags = (markup, depth) => {
|
|
36
|
+
if (depth > MAX_DEPTH) throw new Error(`ssr: component nesting exceeded ${MAX_DEPTH} (cycle?)`);
|
|
37
|
+
return markup.replace(CUSTOM_TAG, (match, tag, attrString) => {
|
|
38
|
+
if (!registry.has(tag)) return match;
|
|
39
|
+
return match + renderComponent(tag, attrString, depth + 1);
|
|
40
|
+
});
|
|
41
|
+
};
|
|
42
|
+
|
|
43
|
+
/** Instantiates a registered component and returns its declarative-shadow (or light) markup. */
|
|
44
|
+
const renderComponent = (tag, attrString, depth) => {
|
|
45
|
+
const element = new (registry.get(tag))();
|
|
46
|
+
element.localName = tag;
|
|
47
|
+
for (const [, name, value] of attrString.matchAll(ATTRIBUTE)) {
|
|
48
|
+
element.setAttribute(name, value ?? '');
|
|
49
|
+
}
|
|
50
|
+
element.connectedCallback?.();
|
|
51
|
+
|
|
52
|
+
if (element.shadowRoot) {
|
|
53
|
+
const inner = renderComponentTags(element.shadowRoot.serialize(), depth);
|
|
54
|
+
return `<template shadowrootmode="${element.shadowRoot.mode}">${inner}</template>`;
|
|
55
|
+
}
|
|
56
|
+
/** Light DOM: rendered content becomes the element's children (client re-render replaces). */
|
|
57
|
+
return renderComponentTags(element.innerHTML, depth);
|
|
58
|
+
};
|
|
59
|
+
|
|
60
|
+
/**
|
|
61
|
+
* Renders a component module to markup.
|
|
62
|
+
*
|
|
63
|
+
* @param url Module URL (the component's file; Node resolves its imports natively — the
|
|
64
|
+
* `.ts`-via-`.js` convention included)
|
|
65
|
+
* @param options `tag` picks the element when the module defines several; `attributes` is a
|
|
66
|
+
* string of attributes for the entry tag
|
|
67
|
+
* @return `{ html, styles }` — `styles` collects light-DOM `@scope` sheets for the page shell
|
|
68
|
+
*/
|
|
69
|
+
export const renderToString = async (url, { tag, attributes = '' } = {}) => {
|
|
70
|
+
const before = new Set(registry.keys());
|
|
71
|
+
const module = await import(url instanceof URL ? url.href : url);
|
|
72
|
+
|
|
73
|
+
if (!tag) {
|
|
74
|
+
if (module.default) {
|
|
75
|
+
for (const [name, Class] of registry) if (Class === module.default) tag = name;
|
|
76
|
+
}
|
|
77
|
+
if (!tag) {
|
|
78
|
+
for (const name of registry.keys()) if (!before.has(name)) tag = name;
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
if (!tag || !registry.has(tag)) {
|
|
82
|
+
throw new Error(`ssr: no custom element definition found for ${url} — pass { tag }`);
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
const attrs = attributes ? ` ${attributes}` : '';
|
|
86
|
+
const html = `<${tag}${attrs}>${renderComponent(tag, attributes, 0)}</${tag}>`;
|
|
87
|
+
return { html, styles: hoistedStyles.join('\n') };
|
|
88
|
+
};
|
|
89
|
+
|
|
90
|
+
export { registry, hoistedStyles, serializeTemplate };
|
|
@@ -0,0 +1,125 @@
|
|
|
1
|
+
import { escapeHtml } from './shim.js';
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* The vera-native template serializer: flattens core's `html` template objects to markup with
|
|
5
|
+
* the renderer's sigil semantics applied server-side.
|
|
6
|
+
*
|
|
7
|
+
* `?bool=${x}` -> `bool=""` when truthy, nothing when falsy
|
|
8
|
+
* `.prop=${x}` -> mirrored to an attribute for form state (value/checked/selected), else dropped
|
|
9
|
+
* `@event=${fn}` -> dropped (behavior is the client's job)
|
|
10
|
+
* `&ref=${r}` -> dropped
|
|
11
|
+
* `attr=${x}` -> quoted, escaped
|
|
12
|
+
* text `${x}` -> escaped; nested templates and arrays flatten; null/undefined/false vanish
|
|
13
|
+
*
|
|
14
|
+
* Like the client renderer, analysis is **per template identity**: each call site's frozen
|
|
15
|
+
* `strings` array is classified once into a plan (slot kinds + pre-trimmed static parts), cached
|
|
16
|
+
* in a WeakMap. Rendering a 100-row list re-uses one plan 100 times instead of re-running the
|
|
17
|
+
* sigil regexes per row — the same template-identity architecture, server-side.
|
|
18
|
+
*
|
|
19
|
+
* `keyed()`/`hold()` wrappers are client-renderer constructs — SSR templates use plain `.map`.
|
|
20
|
+
*/
|
|
21
|
+
|
|
22
|
+
/** `.prop` bindings whose server-side truth belongs in an attribute. */
|
|
23
|
+
const FORM_ATTRIBUTES = ['value', 'checked', 'selected'];
|
|
24
|
+
|
|
25
|
+
const SIGIL_TAIL = /([.?@&])([a-zA-Z][\w-]*)=("?)$/;
|
|
26
|
+
const PLAIN_ATTRIBUTE_TAIL = /[a-zA-Z][\w-]*=$/;
|
|
27
|
+
|
|
28
|
+
/** Slot kinds: text, boolean, form-prop, dropped binding, plain attribute. */
|
|
29
|
+
const TEXT = 0;
|
|
30
|
+
const BOOLEAN = 1;
|
|
31
|
+
const FORM_PROP = 2;
|
|
32
|
+
const DROPPED = 3;
|
|
33
|
+
const ATTRIBUTE = 4;
|
|
34
|
+
|
|
35
|
+
/** strings identity -> { parts, kinds, names } — computed once per call site, ever. */
|
|
36
|
+
const plans = new WeakMap();
|
|
37
|
+
|
|
38
|
+
const compile = (strings) => {
|
|
39
|
+
const parts = [];
|
|
40
|
+
const kinds = [];
|
|
41
|
+
const names = [];
|
|
42
|
+
let skipQuote = false;
|
|
43
|
+
|
|
44
|
+
for (let i = 0; i < strings.length - 1; i++) {
|
|
45
|
+
let part = strings[i];
|
|
46
|
+
if (skipQuote) part = part.startsWith('"') ? part.slice(1) : part;
|
|
47
|
+
|
|
48
|
+
const sigil = SIGIL_TAIL.exec(part);
|
|
49
|
+
if (sigil) {
|
|
50
|
+
/** The space that preceded the binding goes with it, so dropped bindings leave no residue. */
|
|
51
|
+
parts.push(part.slice(0, sigil.index).replace(/ $/, ''));
|
|
52
|
+
skipQuote = sigil[3] === '"';
|
|
53
|
+
const kind = sigil[1];
|
|
54
|
+
if (kind === '?') {
|
|
55
|
+
kinds.push(BOOLEAN);
|
|
56
|
+
} else if (kind === '.' && FORM_ATTRIBUTES.includes(sigil[2])) {
|
|
57
|
+
kinds.push(FORM_PROP);
|
|
58
|
+
} else {
|
|
59
|
+
kinds.push(DROPPED);
|
|
60
|
+
}
|
|
61
|
+
names.push(sigil[2]);
|
|
62
|
+
continue;
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
skipQuote = false;
|
|
66
|
+
const attribute = PLAIN_ATTRIBUTE_TAIL.exec(part);
|
|
67
|
+
if (attribute && /^on[A-Z]/.test(attribute[0])) {
|
|
68
|
+
/** `onClick=${fn}` — the React-shaped event binding; a client concern, dropped like `@`. */
|
|
69
|
+
parts.push(part.slice(0, attribute.index).replace(/ $/, ''));
|
|
70
|
+
kinds.push(DROPPED);
|
|
71
|
+
names.push('');
|
|
72
|
+
continue;
|
|
73
|
+
}
|
|
74
|
+
parts.push(part);
|
|
75
|
+
kinds.push(attribute ? ATTRIBUTE : TEXT);
|
|
76
|
+
names.push('');
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
let last = strings[strings.length - 1];
|
|
80
|
+
if (skipQuote) last = last.startsWith('"') ? last.slice(1) : last;
|
|
81
|
+
parts.push(last);
|
|
82
|
+
|
|
83
|
+
const plan = { parts, kinds, names };
|
|
84
|
+
plans.set(strings, plan);
|
|
85
|
+
return plan;
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
export const serializeTemplate = (template) => {
|
|
89
|
+
const { strings, values } = template;
|
|
90
|
+
const { parts, kinds, names } = plans.get(strings) ?? compile(strings);
|
|
91
|
+
let out = '';
|
|
92
|
+
|
|
93
|
+
for (let i = 0; i < kinds.length; i++) {
|
|
94
|
+
out += parts[i];
|
|
95
|
+
const value = values[i];
|
|
96
|
+
switch (kinds[i]) {
|
|
97
|
+
case TEXT:
|
|
98
|
+
out += serializeValue(value);
|
|
99
|
+
break;
|
|
100
|
+
case BOOLEAN:
|
|
101
|
+
if (value) out += ` ${names[i]}=""`;
|
|
102
|
+
break;
|
|
103
|
+
case FORM_PROP:
|
|
104
|
+
if (value != null && value !== false) out += ` ${names[i]}="${escapeHtml(value === true ? '' : value)}"`;
|
|
105
|
+
break;
|
|
106
|
+
case ATTRIBUTE:
|
|
107
|
+
/** Unquoted `attr=${x}`: quote it so spacey values stay one attribute. */
|
|
108
|
+
out += '"' + escapeHtml(serializeValue(value, true)) + '"';
|
|
109
|
+
break;
|
|
110
|
+
/** DROPPED: '@' and '&' and non-form '.': nothing — client concerns. */
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
return out + parts[kinds.length];
|
|
114
|
+
};
|
|
115
|
+
|
|
116
|
+
const serializeValue = (value, raw = false) => {
|
|
117
|
+
if (value == null || value === false) return '';
|
|
118
|
+
if (Array.isArray(value)) return value.map((entry) => serializeValue(entry, raw)).join('');
|
|
119
|
+
if (typeof value === 'function') return '';
|
|
120
|
+
if (typeof value === 'object') {
|
|
121
|
+
/** Template-shaped (core's html, by shape) recurses; anything else (refs…) is client-side. */
|
|
122
|
+
return value.strings ? serializeTemplate(value) : '';
|
|
123
|
+
}
|
|
124
|
+
return raw ? String(value) : escapeHtml(value);
|
|
125
|
+
};
|
package/src/vera/shim.js
ADDED
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The vera-native server environment: the smallest DOM surface core's server path actually
|
|
3
|
+
* touches. No parse5, no jsdom — elements hold strings, not trees. Installed once, BEFORE
|
|
4
|
+
* `@verajs/core` is imported, so core's `customElements.define` wrap lands on our registry and
|
|
5
|
+
* every component module that executes registers itself here — this is what replaces wcc's
|
|
6
|
+
* acorn walk: **Node resolves the module graph, execution registers the classes.**
|
|
7
|
+
*/
|
|
8
|
+
|
|
9
|
+
/** tag name -> class, filled as component modules execute. */
|
|
10
|
+
export const registry = new Map();
|
|
11
|
+
|
|
12
|
+
/** `@scope (tag) { … }` styles hoisted by light-DOM components — the page shell embeds these. */
|
|
13
|
+
export const hoistedStyles = [];
|
|
14
|
+
|
|
15
|
+
const escapeHtml = (value) =>
|
|
16
|
+
String(value).replace(/[&<>"']/g, (c) => '&#' + c.charCodeAt(0) + ';');
|
|
17
|
+
|
|
18
|
+
class StyleSheetShim {
|
|
19
|
+
replaceSync(cssText) {
|
|
20
|
+
this.cssText = cssText;
|
|
21
|
+
}
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
class ShadowRootShim {
|
|
25
|
+
constructor(mode) {
|
|
26
|
+
this.mode = mode;
|
|
27
|
+
this.innerHTML = '';
|
|
28
|
+
this._styles = [];
|
|
29
|
+
}
|
|
30
|
+
/** Only `adoptStyles`' string path appends here (a `<style>` element shim). */
|
|
31
|
+
appendChild(node) {
|
|
32
|
+
this._styles.push(node.innerHTML);
|
|
33
|
+
return node;
|
|
34
|
+
}
|
|
35
|
+
querySelector() {
|
|
36
|
+
return null; // fresh instance per render — nothing to dedupe against
|
|
37
|
+
}
|
|
38
|
+
/** Constructed sheets land here; serialized alongside string styles. */
|
|
39
|
+
set adoptedStyleSheets(sheets) {
|
|
40
|
+
this._adopted = sheets;
|
|
41
|
+
}
|
|
42
|
+
get adoptedStyleSheets() {
|
|
43
|
+
return this._adopted ?? [];
|
|
44
|
+
}
|
|
45
|
+
serialize() {
|
|
46
|
+
const sheets = (this._adopted ?? []).map((sheet) => sheet.cssText ?? '');
|
|
47
|
+
const styles = [...sheets, ...this._styles].filter(Boolean);
|
|
48
|
+
const styleTags = styles.map((css) => `<style vera-styles>${css}</style>`).join('');
|
|
49
|
+
return styleTags + this.innerHTML;
|
|
50
|
+
}
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
class ElementShim {
|
|
54
|
+
constructor(localName = '') {
|
|
55
|
+
this.localName = localName;
|
|
56
|
+
this.isConnected = true;
|
|
57
|
+
this._attributes = new Map();
|
|
58
|
+
this.innerHTML = '';
|
|
59
|
+
this.shadowRoot = null;
|
|
60
|
+
}
|
|
61
|
+
attachShadow({ mode = 'open' } = {}) {
|
|
62
|
+
this.shadowRoot = new ShadowRootShim(mode);
|
|
63
|
+
return this.shadowRoot;
|
|
64
|
+
}
|
|
65
|
+
getAttribute(name) {
|
|
66
|
+
return this._attributes.has(name) ? this._attributes.get(name) : null;
|
|
67
|
+
}
|
|
68
|
+
setAttribute(name, value) {
|
|
69
|
+
this._attributes.set(name, String(value));
|
|
70
|
+
}
|
|
71
|
+
hasAttribute(name) {
|
|
72
|
+
return this._attributes.has(name);
|
|
73
|
+
}
|
|
74
|
+
removeAttribute(name) {
|
|
75
|
+
this._attributes.delete(name);
|
|
76
|
+
}
|
|
77
|
+
appendChild(node) {
|
|
78
|
+
this.innerHTML += node.innerHTML ?? '';
|
|
79
|
+
return node;
|
|
80
|
+
}
|
|
81
|
+
querySelector() {
|
|
82
|
+
return null;
|
|
83
|
+
}
|
|
84
|
+
querySelectorAll() {
|
|
85
|
+
return [];
|
|
86
|
+
}
|
|
87
|
+
addEventListener() {}
|
|
88
|
+
removeEventListener() {}
|
|
89
|
+
get textContent() {
|
|
90
|
+
return this.innerHTML.replace(/<[^>]*>/g, '');
|
|
91
|
+
}
|
|
92
|
+
set textContent(value) {
|
|
93
|
+
this.innerHTML = escapeHtml(value);
|
|
94
|
+
}
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/** Idempotent. Returns the registry so callers can diff definitions around an import. */
|
|
98
|
+
export const installShims = () => {
|
|
99
|
+
if (globalThis.__veraSsrShimmed) return registry;
|
|
100
|
+
globalThis.__veraSsrShimmed = true;
|
|
101
|
+
|
|
102
|
+
globalThis.HTMLElement = ElementShim;
|
|
103
|
+
globalThis.CSSStyleSheet = StyleSheetShim;
|
|
104
|
+
/** Defined so core's `@scope` support check passes — SSR output gets scoped light-DOM CSS. */
|
|
105
|
+
globalThis.CSSScopeRule = function CSSScopeRule() {};
|
|
106
|
+
|
|
107
|
+
globalThis.customElements = {
|
|
108
|
+
define: (name, Class) => registry.set(name, Class),
|
|
109
|
+
get: (name) => registry.get(name),
|
|
110
|
+
whenDefined: () => Promise.resolve(),
|
|
111
|
+
};
|
|
112
|
+
|
|
113
|
+
globalThis.document = {
|
|
114
|
+
createElement: (localName) => new ElementShim(localName),
|
|
115
|
+
/** Light-DOM styles hoist here — `adoptStyles`' constructed-sheet path. */
|
|
116
|
+
get adoptedStyleSheets() {
|
|
117
|
+
return [];
|
|
118
|
+
},
|
|
119
|
+
set adoptedStyleSheets(sheets) {
|
|
120
|
+
const added = sheets[sheets.length - 1];
|
|
121
|
+
if (added?.cssText) hoistedStyles.push(added.cssText);
|
|
122
|
+
},
|
|
123
|
+
head: {
|
|
124
|
+
appendChild: (node) => {
|
|
125
|
+
if (node?.innerHTML) hoistedStyles.push(node.innerHTML);
|
|
126
|
+
return node;
|
|
127
|
+
},
|
|
128
|
+
},
|
|
129
|
+
};
|
|
130
|
+
|
|
131
|
+
globalThis.requestAnimationFrame = (fn) => setTimeout(fn, 0);
|
|
132
|
+
return registry;
|
|
133
|
+
};
|
|
134
|
+
|
|
135
|
+
export { escapeHtml };
|