npm - typewright - Versions diffs - 0.2.1 - Mend

typewright 0.2.1

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.

Files changed (40) hide show

package/LICENSE +21 -0
package/README.md +168 -0
package/SPEC.md +327 -0
package/dist/chunk-CZQO7TTL.js +1533 -0
package/dist/chunk-CZQO7TTL.js.map +1 -0
package/dist/chunk-KNEKNZXK.js +286 -0
package/dist/chunk-KNEKNZXK.js.map +1 -0
package/dist/chunk-M6IVEMXO.js +1398 -0
package/dist/chunk-M6IVEMXO.js.map +1 -0
package/dist/chunk-NJ7PJKHN.js +652 -0
package/dist/chunk-NJ7PJKHN.js.map +1 -0
package/dist/commands-Z3ndUSza.d.cts +221 -0
package/dist/commands-Z3ndUSza.d.ts +221 -0
package/dist/core/index.cjs +2952 -0
package/dist/core/index.cjs.map +1 -0
package/dist/core/index.d.cts +410 -0
package/dist/core/index.d.ts +410 -0
package/dist/core/index.js +4 -0
package/dist/core/index.js.map +1 -0
package/dist/mdx/index.cjs +662 -0
package/dist/mdx/index.cjs.map +1 -0
package/dist/mdx/index.d.cts +252 -0
package/dist/mdx/index.d.ts +252 -0
package/dist/mdx/index.js +3 -0
package/dist/mdx/index.js.map +1 -0
package/dist/react/index.cjs +7439 -0
package/dist/react/index.cjs.map +1 -0
package/dist/react/index.d.cts +140 -0
package/dist/react/index.d.ts +140 -0
package/dist/react/index.js +3644 -0
package/dist/react/index.js.map +1 -0
package/dist/streaming/index.cjs +1494 -0
package/dist/streaming/index.cjs.map +1 -0
package/dist/streaming/index.d.cts +64 -0
package/dist/streaming/index.d.ts +64 -0
package/dist/streaming/index.js +4 -0
package/dist/streaming/index.js.map +1 -0
package/dist/types-CX1GOx0Y.d.cts +319 -0
package/dist/types-CX1GOx0Y.d.ts +319 -0
package/package.json +128 -0

package/dist/mdx/index.cjs ADDED Viewed

@@ -0,0 +1,662 @@
+'use strict';
+// src/sandbox/host.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function shouldAcceptMessage(event, ctx) {
+  if (event.source !== ctx.source) return false;
+  const data = event.data;
+  if (!isRecord(data)) return false;
+  return data.token === ctx.token;
+}
+function dispatchInbound(data, handlers) {
+  const type = data.type;
+  if (type === "ready") {
+    handlers.onReady?.();
+    return;
+  }
+  if (type === "host") {
+    handlers.onHost?.(data.payload);
+    return;
+  }
+  if (typeof data.id === "number") {
+    handlers.onResult?.(data.id, {
+      html: typeof data.html === "string" ? data.html : void 0,
+      svg: typeof data.svg === "string" ? data.svg : void 0,
+      height: typeof data.height === "number" ? data.height : void 0,
+      error: typeof data.error === "string" ? data.error : void 0
+    });
+  }
+}
+function buildEvaluateMessage(code, props) {
+  return { code, props: props ?? {} };
+}
+var MODULE_BINDINGS = 'var h=self.__tw.h,host=self.__tw.host,components=self.__tw.components,props=self.__tw.props,root=document.getElementById("tw-root");';
+function buildSandboxCsp(extra) {
+  const base = "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data: https:; font-src data:";
+  const trimmed = extra?.trim();
+  return trimmed ? `${base}; ${trimmed}` : base;
+}
+function createChannelToken() {
+  const cryptoObj = globalThis.crypto;
+  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    cryptoObj.getRandomValues(bytes);
+    let out = "";
+    for (const b of bytes) out += b.toString(16).padStart(2, "0");
+    return out;
+  }
+  return `${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+function neutralizeScriptClose(source) {
+  return source.replace(/<\/(script)/gi, "<\\/$1");
+}
+function buildSandboxSrcdoc(params) {
+  const { token, csp, engineSource } = params;
+  const bootstrap = SANDBOX_BOOTSTRAP.replace("__TW_TOKEN__", JSON.stringify(token));
+  return `<!DOCTYPE html><html><head><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="${csp}"><style>html,body{margin:0;padding:0;background:transparent;color:inherit;font:14px/1.5 system-ui,-apple-system,sans-serif}#tw-root{display:block}</style></head><body><div id="tw-root"></div>` + (engineSource ? `<script>
+${neutralizeScriptClose(engineSource)}
+</script>` : "") + `<script>
+${bootstrap}
+</script></body></html>`;
+}
+function createSandbox(opts = {}) {
+  if (typeof document === "undefined") {
+    throw new Error(
+      "typewright/mdx: createSandbox requires a DOM (browser or jsdom); none was found."
+    );
+  }
+  const token = createChannelToken();
+  const csp = buildSandboxCsp(opts.csp);
+  const srcdoc = buildSandboxSrcdoc({ token, csp, engineSource: opts.mermaidEngine });
+  const timeoutMs = opts.timeoutMs ?? 8e3;
+  const iframe = document.createElement("iframe");
+  iframe.setAttribute("sandbox", "allow-scripts");
+  iframe.setAttribute("aria-hidden", "true");
+  iframe.setAttribute("tabindex", "-1");
+  iframe.setAttribute("title", "typewright sandbox");
+  iframe.style.cssText = "position:absolute;width:0;height:0;border:0;visibility:hidden;pointer-events:none;";
+  iframe.srcdoc = srcdoc;
+  const container = opts.container ?? document.body ?? document.documentElement;
+  container.appendChild(iframe);
+  let destroyed = false;
+  let ready = false;
+  let nextId = 1;
+  const outbox = [];
+  const pending = /* @__PURE__ */ new Map();
+  function flush() {
+    if (!ready || destroyed) return;
+    const win = iframe.contentWindow;
+    if (!win) return;
+    while (outbox.length > 0) {
+      const msg = outbox.shift();
+      if (!msg) continue;
+      try {
+        win.postMessage(msg, "*");
+      } catch {
+        const id = msg.id;
+        if (typeof id === "number") {
+          settle(id, {
+            error: "sandbox payload is not serializable \u2014 MDX components/props must be structured-cloneable (functions are not supported across the sandbox)"
+          });
+        }
+      }
+    }
+  }
+  function send(msg) {
+    outbox.push({ ...msg, token });
+    flush();
+  }
+  function settle(id, result) {
+    const entry = pending.get(id);
+    if (!entry) return;
+    pending.delete(id);
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.resolve(result);
+  }
+  function request(kind, extra) {
+    if (destroyed) return Promise.resolve({ error: "sandbox destroyed" });
+    const id = nextId++;
+    return new Promise((resolve) => {
+      const timer = timeoutMs > 0 ? setTimeout(
+        () => settle(id, { error: `sandbox ${kind} timed out after ${timeoutMs}ms` }),
+        timeoutMs
+      ) : void 0;
+      pending.set(id, { resolve, timer });
+      send({ type: kind, id, ...extra });
+    });
+  }
+  function onMessage(event) {
+    if (destroyed) return;
+    if (!shouldAcceptMessage(event, { source: iframe.contentWindow, token })) return;
+    dispatchInbound(event.data, {
+      onReady: () => {
+        ready = true;
+        flush();
+      },
+      onHost: (payload) => {
+        opts.onHostMessage?.(payload);
+      },
+      onResult: (id, result) => settle(id, result)
+    });
+  }
+  window.addEventListener("message", onMessage);
+  return {
+    async evaluate(code, props) {
+      const r = await request("evaluate", buildEvaluateMessage(code, props));
+      return { html: r.html, height: r.height, error: r.error };
+    },
+    async renderMermaid(src) {
+      const r = await request("mermaid", { src });
+      return { svg: r.svg, height: r.height, error: r.error };
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      window.removeEventListener("message", onMessage);
+      for (const [, entry] of pending) {
+        if (entry.timer) clearTimeout(entry.timer);
+        entry.resolve({ error: "sandbox destroyed" });
+      }
+      pending.clear();
+      iframe.remove();
+    }
+  };
+}
+var SANDBOX_BOOTSTRAP = `
+(function () {
+  var TOKEN = __TW_TOKEN__;
+  var root = document.getElementById('tw-root') || document.body;
+  function post(msg) { msg.token = TOKEN; parent.postMessage(msg, '*'); }
+  function measure() {
+    var de = document.documentElement, b = document.body;
+    return Math.max(
+      de ? de.scrollHeight : 0,
+      b ? b.scrollHeight : 0,
+      root ? root.scrollHeight : 0
+    );
+  }
+  function host(payload) { post({ type: 'host', payload: payload }); }
+  function appendChildren(el, children) {
+    for (var i = 0; i < children.length; i++) {
+      var c = children[i];
+      if (c == null || c === false || c === true) continue;
+      if (Object.prototype.toString.call(c) === '[object Array]') { appendChildren(el, c); continue; }
+      if (typeof Node !== 'undefined' && c instanceof Node) { el.appendChild(c); continue; }
+      el.appendChild(document.createTextNode(String(c)));
+    }
+  }
+  // Hyperscript used by compiled MDX: builds real DOM (no innerHTML string
+  // concatenation), returns an element. A function tag is a component.
+  function h(tag, props) {
+    var children = Array.prototype.slice.call(arguments, 2);
+    if (typeof tag === 'function') {
+      var p = {}; for (var pk in (props || {})) p[pk] = props[pk]; p.children = children;
+      return tag(p);
+    }
+    var el = document.createElement(String(tag));
+    if (props) {
+      for (var key in props) {
+        var v = props[key];
+        if (v == null || v === false) continue;
+        if (key === 'className' || key === 'class') { el.setAttribute('class', String(v)); continue; }
+        if (key === 'style' && v && typeof v === 'object') {
+          for (var s in v) { try { el.style[s] = v[s]; } catch (e) {} }
+          continue;
+        }
+        if (key.slice(0, 2) === 'on') continue; // never wire inline handlers
+        if (v === true) { el.setAttribute(key, ''); continue; }
+        el.setAttribute(key, String(v));
+      }
+    }
+    appendChildren(el, children);
+    return el;
+  }
+  var RT = { h: h, host: host, props: {}, components: {}, done: null, error: null };
+  self.__tw = RT;
+  RT.done = function (id, out) {
+    Promise.resolve(out).then(function (value) {
+      try {
+        if (typeof Node !== 'undefined' && value instanceof Node) root.appendChild(value);
+        else if (typeof value === 'string') root.innerHTML = value;
+        // else: the module mounted itself into root
+      } catch (e) {}
+      post({ type: 'result', id: id, html: root.innerHTML, height: measure() });
+    }, function (err) {
+      post({ type: 'result', id: id, error: String((err && err.message) || err) });
+    });
+  };
+  RT.error = function (id, err) {
+    post({ type: 'result', id: id, error: String((err && err.message) || err) });
+  };
+  function runModule(id, code, props, components) {
+    RT.props = props || {};
+    RT.components = components || {};
+    // Inline-script injection (allowed by CSP 'unsafe-inline'; no eval). Setting
+    // textContent \u2014 not innerHTML \u2014 makes any '</script>' in code inert.
+    var wrapped =
+      '"use strict";(function(){' +
+      '${MODULE_BINDINGS}' +
+      'try{var __out=(function(){' + code + '\\n})();self.__tw.done(' + id + ',__out);}' +
+      'catch(__e){self.__tw.error(' + id + ',__e);}})();';
+    var s = document.createElement('script');
+    s.textContent = wrapped;
+    (document.body || document.documentElement).appendChild(s);
+    if (s.parentNode) s.parentNode.removeChild(s);
+  }
+  function renderMermaid(id, src) {
+    try {
+      var engine = null;
+      if (typeof self.__twMermaidRender === 'function') {
+        engine = self.__twMermaidRender;
+      } else if (self.mermaid && typeof self.mermaid.render === 'function') {
+        engine = function (s) {
+          return Promise.resolve(self.mermaid.render('tw-mmd-' + id, s)).then(function (r) {
+            return typeof r === 'string' ? r : (r && r.svg) || '';
+          });
+        };
+      }
+      if (!engine) { post({ type: 'result', id: id, error: 'no mermaid engine injected in sandbox' }); return; }
+      Promise.resolve(engine(src)).then(function (svg) {
+        try { root.innerHTML = svg || ''; } catch (e) {}
+        post({ type: 'result', id: id, svg: svg || '', height: measure() });
+      }, function (err) {
+        post({ type: 'result', id: id, error: String((err && err.message) || err) });
+      });
+    } catch (err) {
+      post({ type: 'result', id: id, error: String((err && err.message) || err) });
+    }
+  }
+  window.addEventListener('message', function (event) {
+    if (event.source !== parent) return;           // only the host frame
+    var data = event.data;
+    if (!data || typeof data !== 'object' || data.token !== TOKEN) return; // token gate
+    // The host component map travels under props.components (see
+    // buildEvaluateMessage); bind it as the module components map.
+    if (data.type === 'evaluate') runModule(data.id, data.code, data.props, data.props && data.props.components);
+    else if (data.type === 'mermaid') renderMermaid(data.id, data.src);
+  });
+  post({ type: 'ready' });
+})();
+`;
+// src/mdx/transform.ts
+function resolveTransform(t) {
+  if (t === void 0) {
+    return async () => {
+      throw new Error("no MDX transform configured");
+    };
+  }
+  if (typeof t === "function") {
+    return async (code, meta) => t(code, meta ?? {});
+  }
+  switch (t) {
+    case "constrained":
+      return async (code) => compileConstrained(code);
+    case "wasm-esbuild":
+      return (code, meta) => transformWithEsbuild(code, meta);
+    case "wasm-swc":
+      return (code, meta) => transformWithSwc(code, meta);
+    default: {
+      const never = t;
+      throw new Error(`typewright/mdx: unknown MDX transform "${String(never)}"`);
+    }
+  }
+}
+async function importOptionalPeer(name) {
+  const specifier = name;
+  try {
+    return await import(
+      /* @vite-ignore */
+      specifier
+    );
+  } catch (cause) {
+    throw new Error(
+      `typewright/mdx: this MDX transform needs the optional peer dependency "${name}", which is not installed. Install it (e.g. \`npm i ${name}\`) or choose a different MdxTransform ("constrained" has zero dependencies).`,
+      { cause }
+    );
+  }
+}
+function loaderFor(meta) {
+  return /\.tsx?$/.test(meta?.filename ?? "") ? "tsx" : "jsx";
+}
+async function transformWithEsbuild(code, meta) {
+  const esbuild = await importOptionalPeer("esbuild-wasm");
+  const transform = esbuild.transform;
+  if (typeof transform !== "function") {
+    throw new Error('typewright/mdx: "esbuild-wasm" is installed but exposes no transform().');
+  }
+  const result = await transform(code, {
+    loader: loaderFor(meta),
+    jsx: "automatic",
+    format: "esm",
+    sourcefile: meta?.filename
+  });
+  return result.code;
+}
+async function transformWithSwc(code, meta) {
+  const swc = await importOptionalPeer("@swc/wasm-web");
+  const transform = swc.transform;
+  if (typeof transform !== "function") {
+    throw new Error('typewright/mdx: "@swc/wasm-web" is installed but exposes no transform().');
+  }
+  const tsx = loaderFor(meta) === "tsx";
+  const result = await transform(code, {
+    filename: meta?.filename,
+    jsc: {
+      parser: tsx ? { syntax: "typescript", tsx: true } : { syntax: "ecmascript", jsx: true },
+      transform: { react: { runtime: "automatic" } }
+    }
+  });
+  return result.code;
+}
+var TransformError = class extends Error {
+  constructor(message, index) {
+    super(`constrained MDX transform: ${message} (at offset ${index})`);
+    this.name = "TransformError";
+  }
+};
+var IDENT_START = /[A-Za-z_$]/;
+var IDENT_PART = /[A-Za-z0-9_$]/;
+var NAME_PART = /[A-Za-z0-9._-]/;
+function compileConstrained(source) {
+  const { body, components } = new ConstrainedParser(source).parse();
+  const parts = [];
+  for (const name of components) {
+    parts.push(`const ${name} = components[${JSON.stringify(name)}];`);
+  }
+  parts.push(`return ${childrenExpr(body)};`);
+  return parts.join("\n");
+}
+function stripModuleLines(source) {
+  const kept = [];
+  for (const line of source.split("\n")) {
+    if (/^\s*(import|export)\b/.test(line)) {
+      kept.push("");
+    } else {
+      kept.push(line);
+    }
+  }
+  return kept.join("\n");
+}
+var ConstrainedParser = class {
+  src;
+  pos = 0;
+  components = /* @__PURE__ */ new Set();
+  constructor(rawSource) {
+    this.src = stripModuleLines(rawSource);
+  }
+  parse() {
+    const body = this.parseChildren(null);
+    this.skipInsignificantWhitespace();
+    if (this.pos < this.src.length) {
+      throw new TransformError(`unexpected "${this.src[this.pos]}"`, this.pos);
+    }
+    return { body, components: [...this.components] };
+  }
+  parseChildren(closeTag) {
+    const children = [];
+    for (; ; ) {
+      if (this.pos >= this.src.length) {
+        if (closeTag !== null) {
+          throw new TransformError(`unclosed <${closeTag}>`, this.pos);
+        }
+        return children;
+      }
+      const ch = this.src[this.pos];
+      if (ch === "<") {
+        if (this.src[this.pos + 1] === "/") {
+          if (closeTag === null) {
+            throw new TransformError("unexpected closing tag", this.pos);
+          }
+          return children;
+        }
+        children.push(this.parseElement());
+      } else if (ch === "{") {
+        children.push({ kind: "expr", source: this.parseBracedExpr() });
+      } else {
+        const text = this.parseText();
+        if (text.value.length > 0) children.push(text);
+      }
+    }
+  }
+  parseText() {
+    let out = "";
+    while (this.pos < this.src.length) {
+      const ch = this.src[this.pos];
+      if (ch === "<" || ch === "{") break;
+      out += ch;
+      this.pos++;
+    }
+    return { kind: "text", value: out };
+  }
+  parseElement() {
+    const start = this.pos;
+    this.expect("<");
+    const name = this.parseName();
+    if (isComponentName(name)) this.components.add(componentRoot(name, start));
+    const attrs = [];
+    for (; ; ) {
+      this.skipWhitespace();
+      const ch = this.src[this.pos];
+      if (ch === void 0) throw new TransformError("unterminated tag", start);
+      if (ch === "/") {
+        this.expect("/");
+        this.expect(">");
+        return { kind: "element", name, attrs, children: [] };
+      }
+      if (ch === ">") {
+        this.pos++;
+        const children = this.parseChildren(name);
+        this.expect("<");
+        this.expect("/");
+        this.skipWhitespace();
+        const closeName = this.parseName();
+        if (closeName !== name) {
+          throw new TransformError(`mismatched closing tag </${closeName}> for <${name}>`, this.pos);
+        }
+        this.skipWhitespace();
+        this.expect(">");
+        return { kind: "element", name, attrs, children };
+      }
+      attrs.push(this.parseAttr());
+    }
+  }
+  parseAttr() {
+    const name = this.parseName();
+    this.skipWhitespace();
+    if (this.src[this.pos] !== "=") {
+      return { name };
+    }
+    this.pos++;
+    this.skipWhitespace();
+    const ch = this.src[this.pos];
+    if (ch === '"' || ch === "'") {
+      return { name, value: { kind: "string", value: this.parseStringLiteral(ch) } };
+    }
+    if (ch === "{") {
+      return { name, value: { kind: "expr", source: this.parseBracedExpr() } };
+    }
+    throw new TransformError(`attribute "${name}" must be a string literal or a {expression}`, this.pos);
+  }
+  parseName() {
+    const start = this.pos;
+    const first = this.src[this.pos];
+    if (first === void 0 || !/[A-Za-z]/.test(first)) {
+      throw new TransformError("expected a tag/attribute name", this.pos);
+    }
+    let out = first;
+    this.pos++;
+    while (this.pos < this.src.length && NAME_PART.test(this.src[this.pos])) {
+      out += this.src[this.pos];
+      this.pos++;
+    }
+    if (out.endsWith(".") || out.endsWith("-")) {
+      throw new TransformError(`invalid name "${out}"`, start);
+    }
+    return out;
+  }
+  parseStringLiteral(quote) {
+    this.expect(quote);
+    let out = "";
+    while (this.pos < this.src.length) {
+      const ch = this.src[this.pos];
+      if (ch === quote) {
+        this.pos++;
+        return out;
+      }
+      if (ch === "\\") {
+        out += ch;
+        this.pos++;
+        if (this.pos < this.src.length) {
+          out += this.src[this.pos];
+          this.pos++;
+        }
+        continue;
+      }
+      out += ch;
+      this.pos++;
+    }
+    throw new TransformError("unterminated string literal", this.pos);
+  }
+  /** Consume `{ … }` and return the validated restricted expression source. */
+  parseBracedExpr() {
+    const start = this.pos;
+    this.expect("{");
+    let depth = 1;
+    let raw = "";
+    while (this.pos < this.src.length && depth > 0) {
+      const ch = this.src[this.pos];
+      if (ch === "{") depth++;
+      else if (ch === "}") {
+        depth--;
+        if (depth === 0) {
+          this.pos++;
+          break;
+        }
+      }
+      raw += ch;
+      this.pos++;
+    }
+    if (depth !== 0) throw new TransformError("unterminated {expression}", start);
+    return validateRestrictedExpr(raw.trim(), start);
+  }
+  expect(ch) {
+    if (this.src[this.pos] !== ch) {
+      throw new TransformError(`expected "${ch}"`, this.pos);
+    }
+    this.pos++;
+  }
+  skipWhitespace() {
+    while (this.pos < this.src.length && /\s/.test(this.src[this.pos])) this.pos++;
+  }
+  /** Skip trailing whitespace-only content when checking for EOF. */
+  skipInsignificantWhitespace() {
+    while (this.pos < this.src.length && /\s/.test(this.src[this.pos])) this.pos++;
+  }
+};
+function isComponentName(name) {
+  return /^[A-Z]/.test(name);
+}
+var SIMPLE_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function componentRoot(name, index) {
+  const segments = name.split(".");
+  for (const seg of segments) {
+    if (!SIMPLE_IDENT.test(seg)) {
+      throw new TransformError(
+        `unsupported component name "${name}" \u2014 component tags must be dot-separated identifiers`,
+        index
+      );
+    }
+  }
+  return segments[0];
+}
+function validateRestrictedExpr(expr, index) {
+  if (expr.length === 0) {
+    throw new TransformError("empty {expression}", index);
+  }
+  if (expr === "true" || expr === "false" || expr === "null") return expr;
+  if (/^-?\d+(\.\d+)?$/.test(expr)) return expr;
+  if (isSimpleMemberPath(expr)) return expr;
+  throw new TransformError(
+    `unsupported expression \`${expr}\` \u2014 only numbers, true/false/null, an identifier, or a simple dotted member (a.b.c) are allowed`,
+    index
+  );
+}
+function isSimpleMemberPath(expr) {
+  const segments = expr.split(".");
+  for (const seg of segments) {
+    if (seg.length === 0) return false;
+    if (!IDENT_START.test(seg[0])) return false;
+    for (let i = 1; i < seg.length; i++) {
+      if (!IDENT_PART.test(seg[i])) return false;
+    }
+  }
+  return true;
+}
+function childrenExpr(children) {
+  const rendered = children.map(nodeExpr).filter((s) => s !== null);
+  if (rendered.length === 0) return "null";
+  if (rendered.length === 1) return rendered[0];
+  return `[${rendered.join(", ")}]`;
+}
+function nodeExpr(node) {
+  if (node.kind === "text") {
+    if (node.value.trim().length === 0 && node.value.indexOf("\n") !== -1) {
+      return null;
+    }
+    return JSON.stringify(node.value);
+  }
+  if (node.kind === "expr") {
+    return node.source;
+  }
+  const tag = isComponentName(node.name) ? node.name : JSON.stringify(node.name);
+  const props = attrsExpr(node.attrs);
+  const kids = node.children.map(nodeExpr).filter((s) => s !== null);
+  const args = [tag, props, ...kids];
+  return `h(${args.join(", ")})`;
+}
+function attrsExpr(attrs) {
+  if (attrs.length === 0) return "null";
+  const entries = attrs.map((attr) => {
+    const key = JSON.stringify(attr.name);
+    if (attr.value === void 0) return `${key}: true`;
+    if (attr.value.kind === "string") return `${key}: ${JSON.stringify(attr.value.value)}`;
+    return `${key}: ${attr.value.source}`;
+  });
+  return `{${entries.join(", ")}}`;
+}
+// src/mdx/index.ts
+async function compileAndRun(opts) {
+  const compile = resolveTransform(opts.transform);
+  const js = await compile(opts.code, opts.meta);
+  const owned = opts.controller === void 0;
+  const sandbox = opts.controller ?? createSandbox(opts.sandbox);
+  try {
+    return await sandbox.evaluate(js, opts.props);
+  } finally {
+    if (owned) sandbox.destroy();
+  }
+}
+exports.buildSandboxCsp = buildSandboxCsp;
+exports.buildSandboxSrcdoc = buildSandboxSrcdoc;
+exports.compileAndRun = compileAndRun;
+exports.compileConstrained = compileConstrained;
+exports.createChannelToken = createChannelToken;
+exports.createSandbox = createSandbox;
+exports.dispatchInbound = dispatchInbound;
+exports.resolveTransform = resolveTransform;
+exports.shouldAcceptMessage = shouldAcceptMessage;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map