@typed/template 0.13.0 → 1.0.0-beta.0

package/dist/internal/encoding.js

@@ -0,0 +1,134 @@
+import { isOption, match } from "effect/Option";
+import { hasProperty, isNullish } from "effect/Predicate";
+import { isHtmlRenderEvent } from "../RenderEvent.js";
+export function escape(s) {
+    switch (typeof s) {
+        case "string":
+        case "number":
+        case "boolean":
+        case "bigint":
+            return escapeHtml(String(s));
+        case "object": {
+            if (isNullish(s)) {
+                return "";
+            }
+            else if (Array.isArray(s)) {
+                return s.map(escape).join("");
+            }
+            else if (s instanceof Date) {
+                return escapeHtml(s.toISOString());
+            }
+            else if (s instanceof RegExp) {
+                return escapeHtml(s.toString());
+            }
+            else {
+                return escapeHtml(JSON.stringify(s));
+            }
+        }
+        default:
+            return escapeHtml(JSON.stringify(s));
+    }
+}
+export function unescape(s) {
+    const unescaped = unescapeHtml(s);
+    const couldBeJson = unescaped[0] === "[" || unescaped === "{";
+    if (couldBeJson) {
+        try {
+            return JSON.parse(unescaped);
+        }
+        catch {
+            return unescaped;
+        }
+    }
+    else {
+        return unescaped;
+    }
+}
+const unescapeHtmlRules = [
+    [/"/g, '"'],
+    [/'/g, "'"],
+    [/:/g, ":"],
+    [/&lt;/g, "<"],
+    [/&gt;/g, ">"],
+    [/&amp;/g, "&"],
+];
+const matchHtmlRegExp = /["'&<>]/;
+export function escapeHtml(str) {
+    if (str.length === 0) {
+        return str;
+    }
+    const match = matchHtmlRegExp.exec(str);
+    if (!match) {
+        return str;
+    }
+    let escape;
+    let html = "";
+    let index = 0;
+    let lastIndex = 0;
+    for (index = match.index; index < str.length; index++) {
+        switch (str.charCodeAt(index)) {
+            case 34: // "
+                escape = "&quot;";
+                break;
+            case 38: // &
+                escape = "&amp;";
+                break;
+            case 39: // '
+                escape = "&#39;";
+                break;
+            case 60: // <
+                escape = "&lt;";
+                break;
+            case 62: // >
+                escape = "&gt;";
+                break;
+            default:
+                continue;
+        }
+        if (lastIndex !== index) {
+            html += str.substring(lastIndex, index);
+        }
+        lastIndex = index + 1;
+        html += escape;
+    }
+    return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+export function unescapeHtml(html) {
+    for (const [from, to] of unescapeHtmlRules) {
+        html = html.replace(from, to);
+    }
+    return html;
+}
+export function renderToString(value, delimiter = "") {
+    if (Array.isArray(value)) {
+        return value.map((v) => renderToString(v, delimiter)).join(delimiter);
+    }
+    if (isNullish(value)) {
+        return "";
+    }
+    if (isOption(value)) {
+        return match(value, {
+            onNone: () => "",
+            onSome: (v) => renderToString(v, delimiter),
+        });
+    }
+    if (isHtmlRenderEvent(value)) {
+        return value.html;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (hasProperty(value, "toString") && typeof value.toString === "function") {
+        const s = value.toString();
+        if (s !== "[object Object]") {
+            return s;
+        }
+    }
+    if (typeof value === "object") {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+export function renderToEscapedString(value, delimiter) {
+    return escape(renderToString(value, delimiter));
+}

package/dist/{dts/internal/v2/hydration-template.d.ts → internal/hydration.d.ts}

@@ -1,44 +1,47 @@
 import { type Inspectable, NodeInspectSymbol } from "effect/Inspectable";
+import type { HydrateContext } from "../HydrateContext.js";
+export declare function getRendered(where: HydrationNode): Node | Node[];
+export declare function findHydrationTemplateByHash(hydrateCtx: HydrateContext, hash: string): HydrationTemplate | null;
 export declare function getHydrationRoot(root: HTMLElement): HydrationElement;
 export declare class HydrationElement implements Inspectable {
+    readonly _tag: "element";
     readonly parentNode: Element;
     readonly childNodes: Array<HydrationNode>;
-    readonly _tag: "element";
     constructor(parentNode: Element, childNodes: Array<HydrationNode>);
     toJSON(): unknown;
     [NodeInspectSymbol](): string;
 }
 export declare class HydrationTemplate implements Inspectable {
+    readonly _tag: "template";
     readonly hash: string;
     readonly childNodes: Array<HydrationNode>;
-    readonly _tag: "template";
     constructor(hash: string, childNodes: Array<HydrationNode>);
     toJSON(): unknown;
     [NodeInspectSymbol](): string;
 }
 export type HydrationNode = HydrationElement | HydrationTemplate | HydrationMany | HydrationHole | HydrationLiteral;
 export declare class HydrationMany implements Inspectable {
+    readonly _tag: "many";
     readonly key: string;
     readonly comment: Comment;
     readonly childNodes: Array<HydrationNode>;
-    readonly _tag: "many";
     constructor(key: string, comment: Comment, childNodes: Array<HydrationNode>);
     toJSON(): unknown;
     [NodeInspectSymbol](): string;
 }
 export declare class HydrationHole implements Inspectable {
+    readonly _tag: "hole";
     readonly index: number;
     readonly startComment: Comment;
     readonly endComment: Comment;
     readonly childNodes: Array<HydrationNode>;
-    readonly _tag: "hole";
     constructor(index: number, startComment: Comment, endComment: Comment, childNodes: Array<HydrationNode>);
     toJSON(): unknown;
     [NodeInspectSymbol](): string;
 }
 export declare class HydrationLiteral implements Inspectable {
-    readonly node: Node;
     readonly _tag: "literal";
+    readonly node: Node;
     constructor(node: Node);
     toJSON(): unknown;
     [NodeInspectSymbol](): string;
@@ -50,5 +53,5 @@ export declare function findHydrationHole(nodes: Array<HydrationNode>, index: nu
 export declare function findHydrationNode(node: HydrationNode, index: number, manyKey?: string): HydrationHole | HydrationMany | null;
 export declare function getNodes(node: HydrationNode): Array<Node>;
 export declare function getNodesExcludingStartComment(node: HydrationNode): Array<Node>;
-export declare function getPreviousNodes(hole: HydrationHole | HydrationMany): Array<Node>;
-//# sourceMappingURL=hydration-template.d.ts.map
+export declare const findHydratePath: (node: HydrationNode, path: ReadonlyArray<number>) => Node;
+//# sourceMappingURL=hydration.d.ts.map

package/dist/internal/hydration.d.ts.map

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

package/dist/{esm/internal/v2/hydration-template.js → internal/hydration.js}

@@ -1,10 +1,28 @@
-import { isComment, isElement, toHtml } from "@typed/wire";
 import { NodeInspectSymbol } from "effect/Inspectable";
-import { CouldNotFindRootElement, CouldNotFindTemplateEndError } from "../errors";
-const TYPED_TEMPLATE_PREFIX = `typed-`;
-const TYPED_TEMPLATE_END_PREFIX = `/typed-`;
-const MANY_PREFIX = `many`;
-const HOLE_PREFIX = `hole`;
+import { CouldNotFindRootElement, CouldNotFindTemplateEndError } from "../errors.js";
+import { isComment, isElement, toHtml } from "../Wire.js";
+const TYPED_TEMPLATE_PREFIX = `t_`;
+const TYPED_TEMPLATE_END_PREFIX = `/t_`;
+const MANY_PREFIX = `/m_`;
+const HOLE_PREFIX = `n_`;
+export function getRendered(where) {
+    const nodes = getNodes(where);
+    if (nodes.length === 1)
+        return nodes[0];
+    return nodes;
+}
+export function findHydrationTemplateByHash(hydrateCtx, hash) {
+    // If there is not a manyKey, we can just find the template by its hash
+    if (hydrateCtx.manyKey === undefined) {
+        return findHydrationTemplate(getChildNodes(hydrateCtx.where), hash);
+    }
+    // If there is a manyKey, we need to find the many node first
+    const many = findHydrationMany(getChildNodes(hydrateCtx.where), hydrateCtx.manyKey);
+    if (many === null)
+        return null;
+    // Then we can find the template by its hash
+    return findHydrationTemplate(getChildNodes(many), hash);
+}
 export function getHydrationRoot(root) {
     const childNodes = Array.from(root.childNodes);
     let hydrationNodes = getHydrationNodes(childNodes);
@@ -61,7 +79,7 @@ function getTemplateEndIndex(nodes, start, hash) {
     throw new CouldNotFindTemplateEndError(hash);
 }
 function getHoleEndIndex(nodes, start, index) {
-    const endHash = `/hole${index}`;
+    const endHash = `/${HOLE_PREFIX}${index}`;
     let templateDepth = 0;
     for (let i = start; i < nodes.length; ++i) {
         const node = nodes[i];
@@ -77,9 +95,9 @@ function getHoleEndIndex(nodes, start, index) {
     throw new CouldNotFindRootElement(index);
 }
 export class HydrationElement {
+    _tag = "element";
     parentNode;
     childNodes;
-    _tag = "element";
     constructor(parentNode, childNodes) {
         this.parentNode = parentNode;
         this.childNodes = childNodes;
@@ -88,7 +106,7 @@ export class HydrationElement {
         return {
             _tag: this._tag,
             parentNode: toHtml(this.parentNode),
-            childNodes: this.childNodes.map((n) => n.toJSON())
+            childNodes: this.childNodes.map((n) => n.toJSON()),
         };
     }
     [NodeInspectSymbol]() {
@@ -96,9 +114,9 @@ export class HydrationElement {
     }
 }
 export class HydrationTemplate {
+    _tag = "template";
     hash;
     childNodes;
-    _tag = "template";
     constructor(hash, childNodes) {
         this.hash = hash;
         this.childNodes = childNodes;
@@ -107,7 +125,7 @@ export class HydrationTemplate {
         return {
             _tag: this._tag,
             hash: this.hash,
-            childNodes: this.childNodes.map((n) => n.toJSON())
+            childNodes: this.childNodes.map((n) => n.toJSON()),
         };
     }
     [NodeInspectSymbol]() {
@@ -115,10 +133,10 @@ export class HydrationTemplate {
     }
 }
 export class HydrationMany {
+    _tag = "many";
     key;
     comment;
     childNodes;
-    _tag = "many";
     constructor(key, comment, childNodes) {
         this.key = key;
         this.comment = comment;
@@ -128,7 +146,7 @@ export class HydrationMany {
         return {
             _tag: this._tag,
             key: this.key,
-            childNodes: this.childNodes.map((n) => n.toJSON())
+            childNodes: this.childNodes.map((n) => n.toJSON()),
         };
     }
     [NodeInspectSymbol]() {
@@ -136,11 +154,11 @@ export class HydrationMany {
     }
 }
 export class HydrationHole {
+    _tag = "hole";
     index;
     startComment;
     endComment;
     childNodes;
-    _tag = "hole";
     constructor(index, startComment, endComment, childNodes) {
         this.index = index;
         this.startComment = startComment;
@@ -151,7 +169,7 @@ export class HydrationHole {
         return {
             _tag: this._tag,
             index: this.index,
-            childNodes: this.childNodes.map((n) => n.toJSON())
+            childNodes: this.childNodes.map((n) => n.toJSON()),
         };
     }
     [NodeInspectSymbol]() {
@@ -159,15 +177,15 @@ export class HydrationHole {
     }
 }
 export class HydrationLiteral {
-    node;
     _tag = "literal";
+    node;
     constructor(node) {
         this.node = node;
     }
     toJSON() {
         return {
             _tag: this._tag,
-            node: toHtml(this.node)
+            node: toHtml(this.node),
         };
     }
     [NodeInspectSymbol]() {
@@ -186,14 +204,18 @@ export function getChildNodes(node) {
     }
 }
 export function findHydrationTemplate(nodes, templateHash) {
+    let index = 0;
     const toProcess = [...nodes];
-    while (toProcess.length > 0) {
-        const node = toProcess.shift();
+    while (index < toProcess.length) {
+        const node = toProcess[index++];
         if (node._tag === "template" && node.hash === templateHash) {
             return node;
         }
         else if (node._tag === "element") {
-            toProcess.push(...node.childNodes);
+            const childNodes = node.childNodes;
+            for (let i = 0; i < childNodes.length; i++) {
+                toProcess.push(childNodes[i]);
+            }
         }
     }
     return null;
@@ -256,10 +278,42 @@ export function getNodesExcludingStartComment(node) {
             return node.childNodes.flatMap(getNodesExcludingStartComment);
     }
 }
-export function getPreviousNodes(hole) {
-    const predicate = hole._tag === "hole"
-        ? (n) => n !== hole.startComment && n !== hole.startComment
-        : (n) => n !== hole.comment;
-    return hole.childNodes.flatMap(getNodes).filter(predicate);
+export const findHydratePath = (node, path) => {
+    if (path.length === 0) {
+        return getNodesExcludingStartComment(node)[0];
+    }
+    // Get initial node without creating full array if possible
+    let current;
+    const firstIndex = path[0];
+    if (node._tag === "element") {
+        current = node.parentNode;
+    }
+    else if (node._tag === "literal") {
+        current = node.node;
+    }
+    else {
+        // For holes, templates, many - need to get nodes array
+        const nodes = getNodesExcludingStartComment(node);
+        current = nodes[firstIndex];
+    }
+    // Traverse remaining path indices
+    for (let i = 1; i < path.length; i++) {
+        const index = path[i];
+        // Use secondary index to skip start comments without creating intermediate arrays
+        let targetIndex = 0;
+        for (let j = 0; j < current.childNodes.length; j++) {
+            const child = current.childNodes[j];
+            if (isNotStartComment(child)) {
+                if (targetIndex === index) {
+                    current = child;
+                    break;
+                }
+                targetIndex++;
+            }
+        }
+    }
+    return current;
+};
+function isNotStartComment(node) {
+    return !isComment(node) || !node.data.startsWith("n_");
 }
-//# sourceMappingURL=hydration-template.js.map

package/dist/internal/keyToPartType.d.ts

@@ -0,0 +1,2 @@
+export declare function keyToPartType(key: string): readonly ["data"] | readonly ["properties"] | readonly ["ref"] | readonly ["class"] | readonly ["boolean", string] | readonly ["property", string] | readonly ["event", string] | readonly ["attr", string];
+//# sourceMappingURL=keyToPartType.d.ts.map

package/dist/internal/keyToPartType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyToPartType.d.ts","sourceRoot":"","sources":["../../src/internal/keyToPartType.ts"],"names":[],"mappings":"AAoEA,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,+MA4CxC"}

package/dist/internal/keyToPartType.js

@@ -0,0 +1,110 @@
+function getCodePoints(str) {
+    return Array.from(str, (c) => c.codePointAt(0));
+}
+// Pre-computed character codes for fast comparisons
+const CHAR_CODES = {
+    QUESTION: "?".codePointAt(0),
+    DOT: ".".codePointAt(0),
+    AT: "@".codePointAt(0),
+    LOWERCASE_O: "o".codePointAt(0),
+    LOWERCASE_N: "n".codePointAt(0),
+    UPPERCASE_A: "A".codePointAt(0),
+    UPPERCASE_Z: "Z".codePointAt(0),
+    CASE_OFFSET: "a".codePointAt(0) - "A".codePointAt(0),
+};
+// Pre-computed string patterns for exact matches
+const PATTERNS = {
+    REF: getCodePoints("ref"),
+    CLASS: getCodePoints("class"),
+    CLASSNAME: getCodePoints("classname"),
+    DATA: getCodePoints(".data"),
+    PROPS: getCodePoints(".props"),
+    PROPERTIES: getCodePoints(".properties"),
+};
+const NAMES = {
+    ATTR: "attr",
+    BOOLEAN: "boolean",
+    REF: "ref",
+    CLASS: "class",
+    DATA: "data",
+    EVENT: "event",
+    PROPERTY: "property",
+    PROPERTIES: "properties",
+};
+const NAME_TUPLE = {
+    DATA: [NAMES.DATA],
+    PROPERTIES: [NAMES.PROPERTIES],
+    REF: [NAMES.REF],
+    CLASS: [NAMES.CLASS],
+    BOOLEAN: (key) => [NAMES.BOOLEAN, key],
+    PROPERTY: (key) => [NAMES.PROPERTY, key],
+    EVENT: (key) => [NAMES.EVENT, fastUncapitalize(key)],
+    ATTR: (key) => [NAMES.ATTR, key],
+};
+// Fast uncapitalize using pre-computed character codes
+function fastUncapitalize(str) {
+    if (str.length === 0)
+        return str;
+    const first = str.codePointAt(0);
+    if (first >= CHAR_CODES.UPPERCASE_A && first <= CHAR_CODES.UPPERCASE_Z) {
+        return String.fromCodePoint(first + CHAR_CODES.CASE_OFFSET) + str.slice(1);
+    }
+    return str;
+}
+// Fast string comparison using pre-computed patterns
+function matchesPattern(str, pattern) {
+    for (let i = 0; i < pattern.length; i++) {
+        if (str.codePointAt(i) !== pattern[i])
+            return false;
+    }
+    return true;
+}
+export function keyToPartType(key) {
+    const len = key.length;
+    // Check for static keys
+    switch (len) {
+        case 3: {
+            if (matchesPattern(key, PATTERNS.REF))
+                return NAME_TUPLE.REF;
+            break;
+        }
+        case 5: {
+            if (matchesPattern(key, PATTERNS.DATA))
+                return NAME_TUPLE.DATA;
+            if (matchesPattern(key, PATTERNS.CLASS))
+                return NAME_TUPLE.CLASS;
+            break;
+        }
+        case 6: {
+            if (matchesPattern(key, PATTERNS.PROPS))
+                return NAME_TUPLE.PROPERTIES;
+            break;
+        }
+        case 9: {
+            if (matchesPattern(key, PATTERNS.CLASSNAME))
+                return NAME_TUPLE.CLASS;
+            break;
+        }
+        case 11: {
+            if (matchesPattern(key, PATTERNS.PROPERTIES))
+                return NAME_TUPLE.PROPERTIES;
+        }
+    }
+    // Check for special prefixes
+    const first = key.codePointAt(0);
+    switch (first) {
+        case CHAR_CODES.QUESTION:
+            return NAME_TUPLE.BOOLEAN(key.slice(1));
+        case CHAR_CODES.DOT:
+            return NAME_TUPLE.PROPERTY(key.slice(1));
+        case CHAR_CODES.AT:
+            return NAME_TUPLE.EVENT(fastUncapitalize(key.slice(1)));
+        case CHAR_CODES.LOWERCASE_O: {
+            if (key.codePointAt(1) === CHAR_CODES.LOWERCASE_N)
+                return NAME_TUPLE.EVENT(fastUncapitalize(key.slice(2)));
+            return NAME_TUPLE.ATTR(key);
+        }
+        default:
+            return NAME_TUPLE.ATTR(key);
+    }
+}

package/dist/internal/meta.d.ts

@@ -0,0 +1,17 @@
+export declare const PART_REGEX: RegExp;
+export declare const STRICT_PART_REGEX: RegExp;
+export declare const PART_STRING: (i: number) => string;
+export declare const TEMPLATE_START_COMMENT: (hash: string) => string;
+export declare const TEMPLATE_END_COMMENT: (hash: string) => string;
+export declare const TEXT_START = "<!--txt-->";
+export declare const TYPED_NODE_START: (i: number) => string;
+export declare const TYPED_NODE_END: (i: number) => string;
+export declare const TYPED_COMMENT_PART: (i: number) => string;
+export declare const isTemplateStartComment: (comment: {
+    nodeValue: string;
+}) => boolean;
+export declare const isTemplateEndComment: (comment: {
+    nodeValue: string;
+}) => boolean;
+export declare const stripTypedTemplateComments: (html: string) => string;
+//# sourceMappingURL=meta.d.ts.map

package/dist/internal/meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/internal/meta.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,QAAqB,CAAC;AAC7C,eAAO,MAAM,iBAAiB,QAAqB,CAAC;AACpD,eAAO,MAAM,WAAW,GAAI,GAAG,MAAM,WAAe,CAAC;AAErD,eAAO,MAAM,sBAAsB,GAAI,MAAM,MAAM,WAAuB,CAAC;AAC3E,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,WAAwB,CAAC;AAE1E,eAAO,MAAM,UAAU,eAAe,CAAC;AAEvC,eAAO,MAAM,gBAAgB,GAAI,GAAG,MAAM,WAAoB,CAAC;AAC/D,eAAO,MAAM,cAAc,GAAI,GAAG,MAAM,WAAqB,CAAC;AAE9D,eAAO,MAAM,kBAAkB,GAAI,GAAG,MAAM,WAAoB,CAAC;AAKjE,eAAO,MAAM,sBAAsB,GAAI,SAAS;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,YACb,CAAC;AAEzD,eAAO,MAAM,oBAAoB,GAAI,SAAS;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,YACb,CAAC;AAEvD,eAAO,MAAM,0BAA0B,GAAI,MAAM,MAAM,WACqC,CAAC"}

package/dist/internal/meta.js

@@ -0,0 +1,14 @@
+export const PART_REGEX = /(\{\{(\d+)\}\})/g;
+export const STRICT_PART_REGEX = /^(\{\{(\d+)\}\})/;
+export const PART_STRING = (i) => `{{${i}}}`;
+export const TEMPLATE_START_COMMENT = (hash) => `<!--t_${hash}-->`;
+export const TEMPLATE_END_COMMENT = (hash) => `<!--/t_${hash}-->`;
+export const TEXT_START = "<!--txt-->";
+export const TYPED_NODE_START = (i) => `<!--n_${i}-->`;
+export const TYPED_NODE_END = (i) => `<!--/n_${i}-->`;
+export const TYPED_COMMENT_PART = (i) => `<!--c_${i}-->`;
+const typedTemplateStartCommentRegex = /<!--[t|n|txt]_(.*?)-->/g;
+const typedTemplateEndCommentRegex = /<!--\/[t|n|txt]_(.*?)-->/g;
+export const isTemplateStartComment = (comment) => typedTemplateStartCommentRegex.test(comment.nodeValue);
+export const isTemplateEndComment = (comment) => typedTemplateEndCommentRegex.test(comment.nodeValue);
+export const stripTypedTemplateComments = (html) => html.replace(typedTemplateStartCommentRegex, "").replace(typedTemplateEndCommentRegex, "");

package/dist/internal/takeOneIfNotRenderEvent.d.ts

@@ -0,0 +1,4 @@
+import { Fx } from "@typed/fx";
+import type { HtmlRenderEvent } from "../RenderEvent.js";
+export declare function takeOneIfNotRenderEvent<A, E, R>(fx: Fx.Fx<A, E, R>): Fx.Fx<A | HtmlRenderEvent, E, R>;
+//# sourceMappingURL=takeOneIfNotRenderEvent.d.ts.map

package/dist/internal/takeOneIfNotRenderEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeOneIfNotRenderEvent.d.ts","sourceRoot":"","sources":["../../src/internal/takeOneIfNotRenderEvent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAQ,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAC7C,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GACjB,EAAE,CAAC,EAAE,CAAC,CAAC,GAAG,eAAe,EAAE,CAAC,EAAE,CAAC,CAAC,CAWlC"}

package/dist/internal/takeOneIfNotRenderEvent.js

@@ -0,0 +1,10 @@
+import * as Effect from "effect/Effect";
+import { Fx, Sink } from "@typed/fx";
+import { isHtmlRenderEvent } from "../RenderEvent.js";
+export function takeOneIfNotRenderEvent(fx) {
+    return Fx.make((sink) => Sink.withEarlyExit(sink, (sink) => fx.run(Sink.make(sink.onFailure, (event) => {
+        if (isHtmlRenderEvent(event) && !event.last)
+            return sink.onSuccess(event);
+        return Effect.flatMap(sink.onSuccess(event), () => sink.earlyExit);
+    }))));
+}

package/dist/internal/templateHash.d.ts

@@ -0,0 +1,2 @@
+export declare function templateHash(strings: ReadonlyArray<string>): string;
+//# sourceMappingURL=templateHash.d.ts.map

package/dist/internal/templateHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templateHash.d.ts","sourceRoot":"","sources":["../../src/internal/templateHash.ts"],"names":[],"mappings":"AAIA,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,UAa1D"}

package/dist/internal/templateHash.js

@@ -0,0 +1,14 @@
+const digestSize = 2;
+const multiplier = 33;
+const fill = 5381;
+export function templateHash(strings) {
+    const hashes = new Uint32Array(digestSize).fill(fill);
+    for (let i = 0; i < strings.length; i++) {
+        const string = strings[i];
+        for (let j = 0; j < string.length; j++) {
+            const key = j % digestSize;
+            hashes[key] = hashes[key] * multiplier + string.charCodeAt(j);
+        }
+    }
+    return btoa(String.fromCharCode(...new Uint8Array(hashes.buffer)));
+}