effect-start 0.23.1 → 0.26.0

package/dist/experimental/SseHttpResponse.js

@@ -1,28 +0,0 @@
-import * as HttpServerResponse from "@effect/platform/HttpServerResponse";
-import * as Duration from "effect/Duration";
-import * as Effect from "effect/Effect";
-import * as Function from "effect/Function";
-import * as Schedule from "effect/Schedule";
-import * as Stream from "effect/Stream";
-import * as StreamExtra from "../StreamExtra.js";
-const DefaultHeartbeatInterval = Duration.seconds(5);
-export const make = (stream, options) => Effect.gen(function* () {
-    const heartbeat = Stream.repeat(Stream.succeed(null), Schedule.spaced(options?.heartbeatInterval ?? DefaultHeartbeatInterval));
-    const encoder = new TextEncoder();
-    const events = Function.pipe(Stream.merge(heartbeat.pipe(Stream.map(() => ":\n\n")), stream.pipe(Stream.map(event => `data: ${JSON.stringify(event)}\n\n`))), 
-    // without Stream.tap, only two events are sent
-    // Effect.fork(Stream.runDrain) doesn't seem to work.
-    // Asked for help here: [2025-04-09]
-    // https://discord.com/channels/795981131316985866/1359523331400929341
-    Stream.tap(v => Effect.gen(function* () { })), Stream.map(str => encoder.encode(str)));
-    const toStream = StreamExtra.toReadableStreamRuntimePatched(yield* Effect.runtime());
-    // see toStream to understand why we're not using
-    // HttpServerResponse.stream here.
-    return HttpServerResponse.raw(toStream(events), {
-        headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-        },
-    });
-});

package/dist/experimental/index.d.ts

@@ -1 +0,0 @@
-export * as EncryptedCookies from "./EncryptedCookies.ts";

package/dist/experimental/index.js

@@ -1 +0,0 @@
-export * as EncryptedCookies from "./EncryptedCookies.js";

package/dist/hyper/Hyper.d.ts

@@ -1,25 +0,0 @@
-import * as Context from "effect/Context";
-import type { JSX } from "./jsx.d.ts";
-type Elements = JSX.IntrinsicElements;
-type Children = JSX.Children;
-export type { Children, Elements, JSX };
-declare const Hyper_base: Context.TagClass<Hyper, "Hyper", {}>;
-export declare class Hyper extends Hyper_base {
-}
-type Primitive = string | number | boolean | null | undefined;
-export type HyperType = string | HyperComponent;
-export type HyperProps = {
-    [key: string]: Primitive | ReadonlyArray<Primitive> | HyperNode | HyperNode[] | null | undefined;
-};
-export type HyperComponent = (props: HyperProps) => HyperNode | Primitive;
-export interface HyperNode {
-    type: HyperType;
-    props: HyperProps;
-}
-export declare function h(type: HyperType, props: HyperProps): HyperNode;
-export declare function unsafeUse<Value>(tag: Context.Tag<any, Value>): Value;
-export type GenericJsxObject = {
-    type: any;
-    props: any;
-};
-export declare function isGenericJsxObject(value: unknown): value is GenericJsxObject;

package/dist/hyper/Hyper.js

@@ -1,23 +0,0 @@
-import * as Context from "effect/Context";
-import * as Fiber from "effect/Fiber";
-import * as Option from "effect/Option";
-export class Hyper extends Context.Tag("Hyper")() {
-}
-const NoChildren = Object.freeze([]);
-export function h(type, props) {
-    return {
-        type,
-        props: {
-            ...props,
-            children: props.children ?? NoChildren,
-        },
-    };
-}
-export function unsafeUse(tag) {
-    const currentFiber = Option.getOrThrow(Fiber.getCurrentFiber());
-    const context = currentFiber.currentContext;
-    return Context.unsafeGet(context, tag);
-}
-export function isGenericJsxObject(value) {
-    return typeof value === "object" && value !== null && "type" in value && "props" in value;
-}

package/dist/hyper/HyperHtml.d.ts

@@ -1,23 +0,0 @@
-/**
- * Renders Hyper JSX nodes to HTML.
- *
- * Effect Start comes with {@link Hyper} and {@link JsxRuntime} to enable
- * JSX support. The advantage of using JSX over HTML strings or templates
- * is type safety and better editor support.
- *
- * JSX nodes are compatible with React's and Solid's.
-
- * You can enable JSX support by updating `tsconfig.json`:
- *
- * {
- *   compilerOptions: {
- *     jsx: "react-jsx",
- *     jsxImportSource: "effect-start" | "react" | "praect" // etc.
- *   }
- * }
- */
-import type * as HyperNode from "./HyperNode.ts";
-import type { JSX } from "./jsx.d.ts";
-export declare function renderToString(node: JSX.Children, hooks?: {
-    onNode?: (node: HyperNode.HyperNode) => void;
-}): string;

package/dist/hyper/HyperHtml.js

@@ -1,150 +0,0 @@
-/**
- * Renders Hyper JSX nodes to HTML.
- *
- * Effect Start comes with {@link Hyper} and {@link JsxRuntime} to enable
- * JSX support. The advantage of using JSX over HTML strings or templates
- * is type safety and better editor support.
- *
- * JSX nodes are compatible with React's and Solid's.
-
- * You can enable JSX support by updating `tsconfig.json`:
- *
- * {
- *   compilerOptions: {
- *     jsx: "react-jsx",
- *     jsxImportSource: "effect-start" | "react" | "praect" // etc.
- *   }
- * }
- */
-const EMPTY_TAGS = [
-    "area",
-    "base",
-    "br",
-    "col",
-    "command",
-    "embed",
-    "hr",
-    "img",
-    "input",
-    "keygen",
-    "link",
-    "meta",
-    "param",
-    "source",
-    "track",
-    "wbr",
-];
-let esc = (str) => String(str).replace(/[&<>"']/g, (s) => `&${map[s]};`);
-let escSQ = (str) => String(str).replace(/[&<>']/g, (s) => `&${map[s]};`);
-let map = {
-    "&": "amp",
-    "<": "lt",
-    ">": "gt",
-    '"': "quot",
-    "'": "#39",
-};
-const RAW_TEXT_TAGS = ["script", "style"];
-export function renderToString(node, hooks) {
-    const stack = [node];
-    let result = "";
-    while (stack.length > 0) {
-        const current = stack.pop();
-        if (typeof current === "string") {
-            if (current.startsWith("<") && current.endsWith(">")) {
-                // This is a closing tag, don't escape it
-                result += current;
-            }
-            else {
-                result += esc(current);
-            }
-            continue;
-        }
-        if (typeof current === "number") {
-            result += esc(current);
-            continue;
-        }
-        if (typeof current === "boolean") {
-            // React-like behavior: booleans render nothing
-            continue;
-        }
-        if (current === null || current === undefined) {
-            // React-like behavior: null/undefined render nothing
-            continue;
-        }
-        if (Array.isArray(current)) {
-            // Handle arrays by pushing all items to stack in reverse order
-            for (let i = current.length - 1; i >= 0; i--) {
-                stack.push(current[i]);
-            }
-            continue;
-        }
-        if (current && typeof current === "object" && current.type) {
-            hooks?.onNode?.(current);
-            if (typeof current.type === "function") {
-                const componentResult = current.type(current.props);
-                if (componentResult != null) {
-                    stack.push(componentResult);
-                }
-                continue;
-            }
-            const { type, props } = current;
-            result += `<${type}`;
-            for (const key in props) {
-                if (key !== "children" &&
-                    key !== "innerHTML" && // Solid-specific
-                    key !== "dangerouslySetInnerHTML" && // React-specific
-                    props[key] !== false &&
-                    props[key] != null) {
-                    if (props[key] === true) {
-                        result += ` ${esc(key)}`;
-                    }
-                    else {
-                        const resolvedKey = key === "className" ? "class" : key;
-                        const value = props[key];
-                        if (key.startsWith("data-") && typeof value === "function") {
-                            result += ` ${esc(resolvedKey)}="${esc(value.toString())}"`;
-                        }
-                        else if (key.startsWith("data-") && typeof value === "object") {
-                            result += ` ${esc(resolvedKey)}='${escSQ(JSON.stringify(value))}'`;
-                        }
-                        else {
-                            result += ` ${esc(resolvedKey)}="${esc(value)}"`;
-                        }
-                    }
-                }
-            }
-            result += ">";
-            if (!EMPTY_TAGS.includes(type)) {
-                stack.push(`</${type}>`);
-                // React-specific
-                const html = props.dangerouslySetInnerHTML?.__html ?? props.innerHTML;
-                if (html) {
-                    result += html;
-                }
-                else {
-                    const children = props.children;
-                    if (type === "script" && typeof children === "function") {
-                        result += `(${children.toString()})(window)`;
-                    }
-                    else if (RAW_TEXT_TAGS.includes(type) && children != null) {
-                        result += Array.isArray(children) ? children.join("") : children;
-                    }
-                    else if (Array.isArray(children)) {
-                        for (let i = children.length - 1; i >= 0; i--) {
-                            stack.push(children[i]);
-                        }
-                    }
-                    else if (children != null) {
-                        stack.push(children);
-                    }
-                }
-            }
-        }
-        else if (current && typeof current === "object") {
-            // Handle objects without type property - convert to string or ignore
-            // This prevents [object Object] from appearing
-            continue;
-        }
-    }
-    return result;
-}

package/dist/hyper/HyperHtml.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hyper/HyperHtml.test.js

@@ -1,197 +0,0 @@
-import { jsx as _jsx } from "effect-start/jsx-runtime";
-/** @jsxImportSource effect-start */
-import * as test from "bun:test";
-import * as HyperHtml from "./HyperHtml.js";
-import * as HyperNode from "./HyperNode.js";
-test.it("boolean true attributes render without value (React-like)", () => {
-    const node = HyperNode.make("div", {
-        hidden: true,
-        disabled: true,
-        "data-active": true,
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe("<div hidden disabled data-active></div>");
-});
-test.it("boolean false attributes are omitted", () => {
-    const node = HyperNode.make("div", {
-        hidden: false,
-        disabled: false,
-        "data-active": false,
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe("<div></div>");
-});
-test.it("string attributes render with values", () => {
-    const node = HyperNode.make("div", {
-        id: "test",
-        class: "my-class",
-        "data-value": "hello",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe('<div id="test" class="my-class" data-value="hello"></div>');
-});
-test.it("number attributes render with values", () => {
-    const node = HyperNode.make("input", {
-        type: "number",
-        min: 0,
-        max: 100,
-        value: 50,
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe('<input type="number" min="0" max="100" value="50">');
-});
-test.it("null and undefined attributes are omitted", () => {
-    const node = HyperNode.make("div", {
-        id: null,
-        class: undefined,
-        "data-test": "value",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe('<div data-test="value"></div>');
-});
-test.it("mixed boolean and string attributes", () => {
-    const node = HyperNode.make("input", {
-        type: "checkbox",
-        checked: true,
-        disabled: false,
-        name: "test",
-        value: "on",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe('<input type="checkbox" checked name="test" value="on">');
-});
-test.it("data-* attributes with object values use single-quoted JSON", () => {
-    const node = HyperNode.make("div", {
-        "data-signals": {
-            draft: "",
-            pendingDraft: "",
-            username: "User123",
-        },
-    });
-    const html = HyperHtml.renderToString(node);
-    test
-        .expect(html)
-        .toBe(`<div data-signals='{"draft":"","pendingDraft":"","username":"User123"}'></div>`);
-});
-test.it("data-* attributes with array values use single-quoted JSON", () => {
-    const node = HyperNode.make("div", {
-        "data-items": [1, 2, 3],
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe("<div data-items='[1,2,3]'></div>");
-});
-test.it("data-* attributes with nested object values use single-quoted JSON", () => {
-    const node = HyperNode.make("div", {
-        "data-config": {
-            user: { name: "John", active: true },
-            settings: { theme: "dark" },
-        },
-    });
-    const html = HyperHtml.renderToString(node);
-    test
-        .expect(html)
-        .toBe(`<div data-config='{"user":{"name":"John","active":true},"settings":{"theme":"dark"}}'></div>`);
-});
-test.it("data-* object values with single quotes in values are escaped", () => {
-    const node = HyperNode.make("div", {
-        "data-signals": {
-            message: "it's a test",
-            name: "O'Brien",
-        },
-    });
-    const html = HyperHtml.renderToString(node);
-    test
-        .expect(html)
-        .toBe(`<div data-signals='{"message":"it&#39;s a test","name":"O&#39;Brien"}'></div>`);
-});
-test.it("data-* string values are not JSON stringified", () => {
-    const node = HyperNode.make("div", {
-        "data-value": "hello world",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe('<div data-value="hello world"></div>');
-});
-test.it("non-data attributes with object values are not JSON stringified", () => {
-    const node = HyperNode.make("div", {
-        style: "color: red",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe('<div style="color: red"></div>');
-});
-test.it("script with function child renders as IIFE", () => {
-    const handler = (window) => {
-        console.log("Hello from", window.document.title);
-    };
-    const node = HyperNode.make("script", {
-        children: handler,
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe(`<script>(${handler.toString()})(window)</script>`);
-});
-test.it("script with arrow function child renders as IIFE", () => {
-    const node = HyperNode.make("script", {
-        children: (window) => {
-            window.alert("test");
-        },
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toContain("<script>(");
-    test.expect(html).toContain(")(window)</script>");
-    test.expect(html).toContain("window.alert");
-});
-test.it("script with string child renders without escaping", () => {
-    const node = HyperNode.make("script", {
-        children: "console.log('hello')",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe("<script>console.log('hello')</script>");
-});
-test.it("script with string child preserves ampersands and quotes", () => {
-    const node = HyperNode.make("script", {
-        children: 'if (a && b) { console.log("yes") }',
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe('<script>if (a && b) { console.log("yes") }</script>');
-});
-test.it("style tag content is not escaped", () => {
-    const node = HyperNode.make("style", {
-        children: ".foo > .bar { content: '&'; }",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe("<style>.foo > .bar { content: '&'; }</style>");
-});
-test.it("script with attributes and no children", () => {
-    const node = HyperNode.make("script", {
-        type: "module",
-        src: "https://example.com/app.js",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe('<script type="module" src="https://example.com/app.js"></script>');
-});
-test.it("normal tag string content is escaped", () => {
-    const node = HyperNode.make("div", {
-        children: "a && b",
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toBe("<div>a &amp;&amp; b</div>");
-});
-test.it("data-* function values are serialized with toString", () => {
-    const node = HyperNode.make("div", {
-        "data-on-click": () => console.log("clicked"),
-    });
-    const html = HyperHtml.renderToString(node);
-    test.expect(html).toContain("data-on-click=");
-    test.expect(html).toContain("console.log");
-});
-test.it("data-* object values don't render as [object Object]", () => {
-    const html = HyperHtml.renderToString(_jsx("div", { "data-signals": { isOpen: false, count: 42 }, children: "content" }));
-    test.expect(html).toBe(`<div data-signals='{"isOpen":false,"count":42}'>content</div>`);
-    test.expect(html).not.toContain("[object Object]");
-});
-test.it("JSX component with data-* object values", () => {
-    function TestComponent() {
-        return (_jsx("div", { "data-signals": { isOpen: false }, children: _jsx("span", { children: "nested" }) }));
-    }
-    const html = HyperHtml.renderToString(_jsx(TestComponent, {}));
-    test.expect(html).toBe(`<div data-signals='{"isOpen":false}'><span>nested</span></div>`);
-});

package/dist/hyper/HyperNode.d.ts

@@ -1,14 +0,0 @@
-export declare const TypeId: unique symbol;
-export type TypeId = typeof TypeId;
-type Primitive = string | number | boolean | null | undefined;
-export type Type = string | HyperComponent;
-export type Props = {
-    [key: string]: Primitive | HyperNode | Iterable<Primitive | HyperNode> | Record<string, unknown> | ((window: Window) => void);
-};
-export type HyperComponent = (props: Props) => HyperNode | Primitive;
-export interface HyperNode {
-    type: Type;
-    props: Props;
-}
-export declare function make(type: Type, props: Props): HyperNode;
-export {};

package/dist/hyper/HyperNode.js

@@ -1,11 +0,0 @@
-export const TypeId = Symbol.for("effect-start/HyperNode");
-const NoChildren = Object.freeze([]);
-export function make(type, props) {
-    return {
-        type,
-        props: {
-            ...props,
-            children: props.children ?? NoChildren,
-        },
-    };
-}

package/dist/hyper/HyperRoute.d.ts

@@ -1,8 +0,0 @@
-import * as Route from "../Route.ts";
-import type * as RouteBody from "../RouteBody.ts";
-import type { JSX } from "./jsx.d.ts";
-export declare function html<D extends Route.RouteDescriptor.Any, B extends {}, I extends Route.Route.Tuple, E = never, R = never>(handler: RouteBody.HandlerInput<NoInfer<D & B & Route.ExtractBindings<I> & {
-    format: "html";
-}>, JSX.Children, E, R>): (self: Route.RouteSet.RouteSet<D, B, I>) => Route.RouteSet.RouteSet<D, B, [...I, Route.Route.Route<{
-    format: "html";
-}, {}, string, E, R>]>;

package/dist/hyper/HyperRoute.js

@@ -1,32 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as Entity from "../Entity.js";
-import * as Route from "../Route.js";
-import * as HyperHtml from "./HyperHtml.js";
-function renderValue(value) {
-    if (Entity.isEntity(value)) {
-        return Entity.make(HyperHtml.renderToString(value.body), {
-            status: value.status,
-            url: value.url,
-            headers: value.headers,
-        });
-    }
-    return HyperHtml.renderToString(value);
-}
-function normalizeToEffect(handler, context, next) {
-    if (Effect.isEffect(handler)) {
-        return handler;
-    }
-    if (typeof handler === "function") {
-        const result = handler(context, next);
-        if (Effect.isEffect(result)) {
-            return result;
-        }
-        return Effect.gen(function* () {
-            return yield* result;
-        });
-    }
-    return Effect.succeed(handler);
-}
-export function html(handler) {
-    return Route.html((context, next) => Effect.map(normalizeToEffect(handler, context, next), renderValue));
-}

package/dist/hyper/HyperRoute.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/hyper/HyperRoute.test.js

@@ -1,83 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "effect-start/jsx-runtime";
-/** @jsxImportSource effect-start */
-import * as test from "bun:test";
-import * as Effect from "effect/Effect";
-import * as Entity from "../Entity.js";
-import * as Http from "../Http.js";
-import * as Route from "../Route.js";
-import * as RouteHttp from "../RouteHttp.js";
-import * as HyperRoute from "./HyperRoute.js";
-test.describe("HyperRoute.html", () => {
-    test.it("renders JSX to HTML string", async () => {
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(_jsx("div", { children: "Hello World" }))));
-        const response = await Http.fetch(handler, { path: "/" });
-        test.expect(response.status).toBe(200);
-        test.expect(response.headers.get("Content-Type")).toBe("text/html; charset=utf-8");
-        test.expect(await response.text()).toBe("<div>Hello World</div>");
-    });
-    test.it("renders nested JSX elements", async () => {
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(_jsxs("div", { class: "container", children: [_jsx("h1", { children: "Title" }), _jsx("p", { children: "Paragraph" })] }))));
-        const response = await Http.fetch(handler, { path: "/" });
-        test
-            .expect(await response.text())
-            .toBe('<div class="container"><h1>Title</h1><p>Paragraph</p></div>');
-    });
-    test.it("renders JSX from Effect", async () => {
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(Effect.succeed(_jsx("span", { children: "From Effect" })))));
-        const response = await Http.fetch(handler, { path: "/" });
-        test.expect(await response.text()).toBe("<span>From Effect</span>");
-    });
-    test.it("renders JSX from generator function", async () => {
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(Effect.gen(function* () {
-            const name = yield* Effect.succeed("World");
-            return _jsxs("div", { children: ["Hello ", name] });
-        }))));
-        const response = await Http.fetch(handler, { path: "/" });
-        test.expect(await response.text()).toBe("<div>Hello World</div>");
-    });
-    test.it("renders JSX from handler function", async () => {
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html((context) => Effect.succeed(_jsx("div", { children: "Request received" })))));
-        const response = await Http.fetch(handler, { path: "/" });
-        test.expect(await response.text()).toBe("<div>Request received</div>");
-    });
-    test.it("renders JSX with dynamic content", async () => {
-        const items = ["Apple", "Banana", "Cherry"];
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(_jsx("ul", { children: items.map((item) => (_jsx("li", { children: item }))) }))));
-        const response = await Http.fetch(handler, { path: "/" });
-        test.expect(await response.text()).toBe("<ul><li>Apple</li><li>Banana</li><li>Cherry</li></ul>");
-    });
-    test.it("handles Entity with JSX body", async () => {
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(Entity.make(_jsx("div", { children: "With Entity" }), { status: 201 }))));
-        const response = await Http.fetch(handler, { path: "/" });
-        test.expect(response.status).toBe(201);
-        test.expect(await response.text()).toBe("<div>With Entity</div>");
-    });
-    test.it("renders data-* attributes with object values as JSON", async () => {
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(_jsx("div", { "data-signals": {
-                draft: "",
-                pendingDraft: "",
-                username: "User123",
-            }, children: "Content" }))));
-        const response = await Http.fetch(handler, { path: "/" });
-        test
-            .expect(await response.text())
-            .toBe(`<div data-signals='{"draft":"","pendingDraft":"","username":"User123"}'>Content</div>`);
-    });
-    test.it("data-on-click function argument is typed as DataEvent", () => {
-        const node = (_jsx("button", { "data-on:click": (e) => {
-                test.expectTypeOf(e).toEqualTypeOf();
-                test.expectTypeOf(e.window).toEqualTypeOf();
-            } }));
-        test.expect(node).toBeDefined();
-    });
-    test.it("renders script with function child as IIFE", async () => {
-        const handler = RouteHttp.toWebHandler(Route.get(HyperRoute.html(_jsx("script", { children: (window) => {
-                console.log("Hello from", window.document.title);
-            } }))));
-        const response = await Http.fetch(handler, { path: "/" });
-        const text = await response.text();
-        test.expect(text).toContain("<script>(");
-        test.expect(text).toContain(")(window)</script>");
-        test.expect(text).toContain("window.document.title");
-    });
-});

package/dist/hyper/html.d.ts

@@ -1,11 +0,0 @@
-declare const HtmlStringSymbol: unique symbol;
-export interface HtmlString {
-    readonly [HtmlStringSymbol]: true;
-    readonly value: string;
-}
-export type HtmlValue = string | number | bigint | boolean | null | undefined | HtmlString | Function | Record<string, unknown> | ReadonlyArray<HtmlValue>;
-export declare const html: {
-    (strings: TemplateStringsArray, ...values: Array<HtmlValue>): HtmlString;
-    raw(value: string): HtmlString;
-};
-export {};

package/dist/hyper/html.js

@@ -1,30 +0,0 @@
-const HtmlStringSymbol = Symbol.for("HtmlString");
-const makeHtmlString = (value) => ({
-    [HtmlStringSymbol]: true,
-    value,
-});
-const isHtmlString = (value) => typeof value === "object" && value !== null && HtmlStringSymbol in value;
-const resolveValue = (value) => {
-    if (value === null || value === undefined || value === false || value === true)
-        return "";
-    if (isHtmlString(value))
-        return value.value;
-    if (Array.isArray(value))
-        return value.map(resolveValue).join("");
-    if (typeof value === "function")
-        return value.toString();
-    if (typeof value === "object")
-        return JSON.stringify(value);
-    if (typeof value === "string")
-        return value;
-    return String(value);
-};
-export const html = (strings, ...values) => {
-    let result = strings[0];
-    for (let i = 0; i < values.length; i++) {
-        result += resolveValue(values[i]);
-        result += strings[i + 1];
-    }
-    return makeHtmlString(result);
-};
-html.raw = (value) => makeHtmlString(value);