import { escape } from 'html-escaper'; const OnlyResponseCanBeReturned = { name: "OnlyResponseCanBeReturned", title: "Invalid type returned by Astro page.", message: (route, returnedValue) => `Route \`${route ? route : ""}\` returned a \`${returnedValue}\`. Only a [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) can be returned from Astro files.`, hint: "See https://docs.astro.build/en/guides/server-side-rendering/#response for more information." }; const MissingMediaQueryDirective = { name: "MissingMediaQueryDirective", title: "Missing value for `client:media` directive.", message: 'Media query not provided for `client:media` directive. A media query similar to `client:media="(max-width: 600px)"` must be provided' }; const NoMatchingRenderer = { name: "NoMatchingRenderer", title: "No matching renderer found.", message: (componentName, componentExtension, plural, validRenderersCount) => `Unable to render \`${componentName}\`. ${validRenderersCount > 0 ? `There ${plural ? "are" : "is"} ${validRenderersCount} renderer${plural ? "s" : ""} configured in your \`astro.config.mjs\` file, but ${plural ? "none were" : "it was not"} able to server-side render \`${componentName}\`.` : `No valid renderer was found ${componentExtension ? `for the \`.${componentExtension}\` file extension.` : `for this file extension.`}`}`, hint: (probableRenderers) => `Did you mean to enable the ${probableRenderers} integration? See https://docs.astro.build/en/core-concepts/framework-components/ for more information on how to install and configure integrations.` }; const NoClientEntrypoint = { name: "NoClientEntrypoint", title: "No client entrypoint specified in renderer.", message: (componentName, clientDirective, rendererName) => `\`${componentName}\` component has a \`client:${clientDirective}\` directive, but no client entrypoint was provided by \`${rendererName}\`.`, hint: "See https://docs.astro.build/en/reference/integrations-reference/#addrenderer-option for more information on how to configure your renderer." }; const NoClientOnlyHint = { name: "NoClientOnlyHint", title: "Missing hint on client:only directive.", message: (componentName) => `Unable to render \`${componentName}\`. When using the \`client:only\` hydration strategy, Astro needs a hint to use the correct renderer.`, hint: (probableRenderers) => `Did you mean to pass \`client:only="${probableRenderers}"\`? See https://docs.astro.build/en/reference/directives-reference/#clientonly for more information on client:only` }; const InvalidComponentArgs = { name: "InvalidComponentArgs", title: "Invalid component arguments.", message: (name) => `Invalid arguments passed to${name ? ` <${name}>` : ""} component.`, hint: "Astro components cannot be rendered directly via function call, such as `Component()` or `{items.map(Component)}`." }; const AstroGlobUsedOutside = { name: "AstroGlobUsedOutside", title: "Astro.glob() used outside of an Astro file.", message: (globStr) => `\`Astro.glob(${globStr})\` can only be used in \`.astro\` files. \`import.meta.glob(${globStr})\` can be used instead to achieve a similar result.`, hint: "See Vite's documentation on `import.meta.glob` for more information: https://vitejs.dev/guide/features.html#glob-import" }; const AstroGlobNoMatch = { name: "AstroGlobNoMatch", title: "Astro.glob() did not match any files.", message: (globStr) => `\`Astro.glob(${globStr})\` did not return any matching files. Check the pattern for typos.` }; function normalizeLF(code) { return code.replace(/\r\n|\r(?!\n)|\n/g, "\n"); } function codeFrame(src, loc) { if (!loc || loc.line === void 0 || loc.column === void 0) { return ""; } const lines = normalizeLF(src).split("\n").map((ln) => ln.replace(/\t/g, " ")); const visibleLines = []; for (let n = -2; n <= 2; n++) { if (lines[loc.line + n]) visibleLines.push(loc.line + n); } let gutterWidth = 0; for (const lineNo of visibleLines) { let w = `> ${lineNo}`; if (w.length > gutterWidth) gutterWidth = w.length; } let output = ""; for (const lineNo of visibleLines) { const isFocusedLine = lineNo === loc.line - 1; output += isFocusedLine ? "> " : " "; output += `${lineNo + 1} | ${lines[lineNo]} `; if (isFocusedLine) output += `${Array.from({ length: gutterWidth }).join(" ")} | ${Array.from({ length: loc.column }).join(" ")}^ `; } return output; } class AstroError extends Error { constructor(props, ...params) { super(...params); this.type = "AstroError"; const { name, title, message, stack, location, hint, frame } = props; this.title = title; this.name = name; if (message) this.message = message; this.stack = stack ? stack : this.stack; this.loc = location; this.hint = hint; this.frame = frame; } setLocation(location) { this.loc = location; } setName(name) { this.name = name; } setMessage(message) { this.message = message; } setHint(hint) { this.hint = hint; } setFrame(source, location) { this.frame = codeFrame(source, location); } static is(err) { return err.type === "AstroError"; } } function validateArgs(args) { if (args.length !== 3) return false; if (!args[0] || typeof args[0] !== "object") return false; return true; } function baseCreateComponent(cb, moduleId, propagation) { var _a; const name = ((_a = moduleId == null ? void 0 : moduleId.split("/").pop()) == null ? void 0 : _a.replace(".astro", "")) ?? ""; const fn = (...args) => { if (!validateArgs(args)) { throw new AstroError({ ...InvalidComponentArgs, message: InvalidComponentArgs.message(name) }); } return cb(...args); }; Object.defineProperty(fn, "name", { value: name, writable: false }); fn.isAstroComponentFactory = true; fn.moduleId = moduleId; fn.propagation = propagation; return fn; } function createComponentWithOptions(opts) { const cb = baseCreateComponent(opts.factory, opts.moduleId, opts.propagation); return cb; } function createComponent(arg1, moduleId, propagation) { if (typeof arg1 === "function") { return baseCreateComponent(arg1, moduleId, propagation); } else { return createComponentWithOptions(arg1); } } const ASTRO_VERSION = "2.10.7"; function createAstroGlobFn() { const globHandler = (importMetaGlobResult) => { if (typeof importMetaGlobResult === "string") { throw new AstroError({ ...AstroGlobUsedOutside, message: AstroGlobUsedOutside.message(JSON.stringify(importMetaGlobResult)) }); } let allEntries = [...Object.values(importMetaGlobResult)]; if (allEntries.length === 0) { throw new AstroError({ ...AstroGlobNoMatch, message: AstroGlobNoMatch.message(JSON.stringify(importMetaGlobResult)) }); } return Promise.all(allEntries.map((fn) => fn())); }; return globHandler; } function createAstro(site) { return { site: site ? new URL(site) : void 0, generator: `Astro v${ASTRO_VERSION}`, glob: createAstroGlobFn() }; } function serializeListValue(value) { const hash = {}; push(value); return Object.keys(hash).join(" "); function push(item) { if (item && typeof item.forEach === "function") item.forEach(push); else if (item === Object(item)) Object.keys(item).forEach((name) => { if (item[name]) push(name); }); else { item = item === false || item == null ? "" : String(item).trim(); if (item) { item.split(/\s+/).forEach((name) => { hash[name] = true; }); } } } } function isPromise(value) { return !!value && typeof value === "object" && typeof value.then === "function"; } const escapeHTML = escape; class HTMLString extends String { get [Symbol.toStringTag]() { return "HTMLString"; } } const markHTMLString = (value) => { if (value instanceof HTMLString) { return value; } if (typeof value === "string") { return new HTMLString(value); } return value; }; function isHTMLString(value) { return Object.prototype.toString.call(value) === "[object HTMLString]"; } const PROP_TYPE = { Value: 0, JSON: 1, // Actually means Array RegExp: 2, Date: 3, Map: 4, Set: 5, BigInt: 6, URL: 7, Uint8Array: 8, Uint16Array: 9, Uint32Array: 10 }; function serializeArray(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) { if (parents.has(value)) { throw new Error(`Cyclic reference detected while serializing props for <${metadata.displayName} client:${metadata.hydrate}>! Cyclic references cannot be safely serialized for client-side usage. Please remove the cyclic reference.`); } parents.add(value); const serialized = value.map((v) => { return convertToSerializedForm(v, metadata, parents); }); parents.delete(value); return serialized; } function serializeObject(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) { if (parents.has(value)) { throw new Error(`Cyclic reference detected while serializing props for <${metadata.displayName} client:${metadata.hydrate}>! Cyclic references cannot be safely serialized for client-side usage. Please remove the cyclic reference.`); } parents.add(value); const serialized = Object.fromEntries( Object.entries(value).map(([k, v]) => { return [k, convertToSerializedForm(v, metadata, parents)]; }) ); parents.delete(value); return serialized; } function convertToSerializedForm(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) { const tag = Object.prototype.toString.call(value); switch (tag) { case "[object Date]": { return [PROP_TYPE.Date, value.toISOString()]; } case "[object RegExp]": { return [PROP_TYPE.RegExp, value.source]; } case "[object Map]": { return [PROP_TYPE.Map, serializeArray(Array.from(value), metadata, parents)]; } case "[object Set]": { return [PROP_TYPE.Set, serializeArray(Array.from(value), metadata, parents)]; } case "[object BigInt]": { return [PROP_TYPE.BigInt, value.toString()]; } case "[object URL]": { return [PROP_TYPE.URL, value.toString()]; } case "[object Array]": { return [PROP_TYPE.JSON, serializeArray(value, metadata, parents)]; } case "[object Uint8Array]": { return [PROP_TYPE.Uint8Array, Array.from(value)]; } case "[object Uint16Array]": { return [PROP_TYPE.Uint16Array, Array.from(value)]; } case "[object Uint32Array]": { return [PROP_TYPE.Uint32Array, Array.from(value)]; } default: { if (value !== null && typeof value === "object") { return [PROP_TYPE.Value, serializeObject(value, metadata, parents)]; } else if (value === void 0) { return [PROP_TYPE.Value]; } else { return [PROP_TYPE.Value, value]; } } } } function serializeProps(props, metadata) { const serialized = JSON.stringify(serializeObject(props, metadata)); return serialized; } const transitionDirectivesToCopyOnIsland = Object.freeze([ "data-astro-transition-scope", "data-astro-transition-persist" ]); function extractDirectives(inputProps, clientDirectives) { let extracted = { isPage: false, hydration: null, props: {} }; for (const [key, value] of Object.entries(inputProps)) { if (key.startsWith("server:")) { if (key === "server:root") { extracted.isPage = true; } } if (key.startsWith("client:")) { if (!extracted.hydration) { extracted.hydration = { directive: "", value: "", componentUrl: "", componentExport: { value: "" } }; } switch (key) { case "client:component-path": { extracted.hydration.componentUrl = value; break; } case "client:component-export": { extracted.hydration.componentExport.value = value; break; } case "client:component-hydration": { break; } case "client:display-name": { break; } default: { extracted.hydration.directive = key.split(":")[1]; extracted.hydration.value = value; if (!clientDirectives.has(extracted.hydration.directive)) { const hydrationMethods = Array.from(clientDirectives.keys()).map((d) => `client:${d}`).join(", "); throw new Error( `Error: invalid hydration directive "${key}". Supported hydration methods: ${hydrationMethods}` ); } if (extracted.hydration.directive === "media" && typeof extracted.hydration.value !== "string") { throw new AstroError(MissingMediaQueryDirective); } break; } } } else if (key === "class:list") { if (value) { extracted.props[key.slice(0, -5)] = serializeListValue(value); } } else { extracted.props[key] = value; } } for (const sym of Object.getOwnPropertySymbols(inputProps)) { extracted.props[sym] = inputProps[sym]; } return extracted; } async function generateHydrateScript(scriptOptions, metadata) { const { renderer, result, astroId, props, attrs } = scriptOptions; const { hydrate, componentUrl, componentExport } = metadata; if (!componentExport.value) { throw new Error( `Unable to resolve a valid export for "${metadata.displayName}"! Please open an issue at https://astro.build/issues!` ); } const island = { children: "", props: { // This is for HMR, probably can avoid it in prod uid: astroId } }; if (attrs) { for (const [key, value] of Object.entries(attrs)) { island.props[key] = escapeHTML(value); } } island.props["component-url"] = await result.resolve(decodeURI(componentUrl)); if (renderer.clientEntrypoint) { island.props["component-export"] = componentExport.value; island.props["renderer-url"] = await result.resolve(decodeURI(renderer.clientEntrypoint)); island.props["props"] = escapeHTML(serializeProps(props, metadata)); } island.props["ssr"] = ""; island.props["client"] = hydrate; let beforeHydrationUrl = await result.resolve("astro:scripts/before-hydration.js"); if (beforeHydrationUrl.length) { island.props["before-hydration-url"] = beforeHydrationUrl; } island.props["opts"] = escapeHTML( JSON.stringify({ name: metadata.displayName, value: metadata.hydrateArgs || "" }) ); transitionDirectivesToCopyOnIsland.forEach((name) => { if (props[name]) { island.props[name] = props[name]; } }); return island; } /** * shortdash - https://github.com/bibig/node-shorthash * * @license * * (The MIT License) * * Copyright (c) 2013 Bibig * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ const dictionary = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXY"; const binary = dictionary.length; function bitwise(str) { let hash = 0; if (str.length === 0) return hash; for (let i = 0; i < str.length; i++) { const ch = str.charCodeAt(i); hash = (hash << 5) - hash + ch; hash = hash & hash; } return hash; } function shorthash(text) { let num; let result = ""; let integer = bitwise(text); const sign = integer < 0 ? "Z" : ""; integer = Math.abs(integer); while (integer >= binary) { num = integer % binary; integer = Math.floor(integer / binary); result = dictionary[num] + result; } if (integer > 0) { result = dictionary[integer] + result; } return sign + result; } function isAstroComponentFactory(obj) { return obj == null ? false : obj.isAstroComponentFactory === true; } function isAPropagatingComponent(result, factory) { let hint = factory.propagation || "none"; if (factory.moduleId && result.componentMetadata.has(factory.moduleId) && hint === "none") { hint = result.componentMetadata.get(factory.moduleId).propagation; } return hint === "in-tree" || hint === "self"; } const headAndContentSym = Symbol.for("astro.headAndContent"); function isHeadAndContent(obj) { return typeof obj === "object" && !!obj[headAndContentSym]; } var astro_island_prebuilt_default = `(()=>{var d;{let p={0:t=>u(t),1:t=>l(t),2:t=>new RegExp(t),3:t=>new Date(t),4:t=>new Map(l(t)),5:t=>new Set(l(t)),6:t=>BigInt(t),7:t=>new URL(t),8:t=>new Uint8Array(t),9:t=>new Uint16Array(t),10:t=>new Uint32Array(t)},h=t=>{let[e,n]=t;return e in p?p[e](n):void 0},l=t=>t.map(h),u=t=>typeof t!="object"||t===null?t:Object.fromEntries(Object.entries(t).map(([e,n])=>[e,h(n)]));customElements.get("astro-island")||customElements.define("astro-island",(d=class extends HTMLElement{constructor(){super(...arguments);this.hydrate=async()=>{var i;if(!this.hydrator||!this.isConnected)return;let e=(i=this.parentElement)==null?void 0:i.closest("astro-island[ssr]");if(e){e.addEventListener("astro:hydrate",this.hydrate,{once:!0});return}let n=this.querySelectorAll("astro-slot"),o={},a=this.querySelectorAll("template[data-astro-template]");for(let r of a){let s=r.closest(this.tagName);s!=null&&s.isSameNode(this)&&(o[r.getAttribute("data-astro-template")||"default"]=r.innerHTML,r.remove())}for(let r of n){let s=r.closest(this.tagName);s!=null&&s.isSameNode(this)&&(o[r.getAttribute("name")||"default"]=r.innerHTML)}let c;try{c=this.hasAttribute("props")?u(JSON.parse(this.getAttribute("props"))):{}}catch(r){let s=this.getAttribute("component-url")||"",y=this.getAttribute("component-export");throw y&&(s+=\` (export \${y})\`),console.error(\`[hydrate] Error parsing props for component \${s}\`,this.getAttribute("props"),r),r}await this.hydrator(this)(this.Component,c,o,{client:this.getAttribute("client")}),this.removeAttribute("ssr"),this.dispatchEvent(new CustomEvent("astro:hydrate"))}}connectedCallback(){!this.hasAttribute("await-children")||this.firstChild?this.childrenConnectedCallback():new MutationObserver((e,n)=>{n.disconnect(),setTimeout(()=>this.childrenConnectedCallback(),0)}).observe(this,{childList:!0})}async childrenConnectedCallback(){let e=this.getAttribute("before-hydration-url");e&&await import(e),this.start()}start(){let e=JSON.parse(this.getAttribute("opts")),n=this.getAttribute("client");if(Astro[n]===void 0){window.addEventListener(\`astro:\${n}\`,()=>this.start(),{once:!0});return}Astro[n](async()=>{let o=this.getAttribute("renderer-url"),[a,{default:c}]=await Promise.all([import(this.getAttribute("component-url")),o?import(o):()=>()=>{}]),i=this.getAttribute("component-export")||"default";if(!i.includes("."))this.Component=a[i];else{this.Component=a;for(let r of i.split("."))this.Component=this.Component[r]}return this.hydrator=c,this.hydrate},e,this)}attributeChangedCallback(){this.hydrate()}},d.observedAttributes=["props"],d))}})();`; const ISLAND_STYLES = ``; function determineIfNeedsHydrationScript(result) { if (result._metadata.hasHydrationScript) { return false; } return result._metadata.hasHydrationScript = true; } function determinesIfNeedsDirectiveScript(result, directive) { if (result._metadata.hasDirectives.has(directive)) { return false; } result._metadata.hasDirectives.add(directive); return true; } function getDirectiveScriptText(result, directive) { const clientDirectives = result.clientDirectives; const clientDirective = clientDirectives.get(directive); if (!clientDirective) { throw new Error(`Unknown directive: ${directive}`); } return clientDirective; } function getPrescripts(result, type, directive) { switch (type) { case "both": return `${ISLAND_STYLES}`; case "directive": return ``; } return ""; } const voidElementNames = /^(area|base|br|col|command|embed|hr|img|input|keygen|link|meta|param|source|track|wbr)$/i; const htmlBooleanAttributes = /^(allowfullscreen|async|autofocus|autoplay|controls|default|defer|disabled|disablepictureinpicture|disableremoteplayback|formnovalidate|hidden|loop|nomodule|novalidate|open|playsinline|readonly|required|reversed|scoped|seamless|itemscope)$/i; const htmlEnumAttributes = /^(contenteditable|draggable|spellcheck|value)$/i; const svgEnumAttributes = /^(autoReverse|externalResourcesRequired|focusable|preserveAlpha)$/i; const STATIC_DIRECTIVES = /* @__PURE__ */ new Set(["set:html", "set:text"]); const toIdent = (k) => k.trim().replace(/(?:(?!^)\b\w|\s+|[^\w]+)/g, (match, index) => { if (/[^\w]|\s/.test(match)) return ""; return index === 0 ? match : match.toUpperCase(); }); const toAttributeString = (value, shouldEscape = true) => shouldEscape ? String(value).replace(/&/g, "&").replace(/"/g, """) : value; const kebab = (k) => k.toLowerCase() === k ? k : k.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`); const toStyleString = (obj) => Object.entries(obj).map(([k, v]) => { if (k[0] !== "-" && k[1] !== "-") return `${kebab(k)}:${v}`; if (kebab(k) !== k) return `${kebab(k)}:var(${k});${k}:${v}`; return `${k}:${v}`; }).join(";"); function defineScriptVars(vars) { var _a; let output = ""; for (const [key, value] of Object.entries(vars)) { output += `const ${toIdent(key)} = ${(_a = JSON.stringify(value)) == null ? void 0 : _a.replace( /<\/script>/g, "\\x3C/script>" )}; `; } return markHTMLString(output); } function formatList(values) { if (values.length === 1) { return values[0]; } return `${values.slice(0, -1).join(", ")} or ${values[values.length - 1]}`; } function addAttribute(value, key, shouldEscape = true) { if (value == null) { return ""; } if (value === false) { if (htmlEnumAttributes.test(key) || svgEnumAttributes.test(key)) { return markHTMLString(` ${key}="false"`); } return ""; } if (STATIC_DIRECTIVES.has(key)) { console.warn(`[astro] The "${key}" directive cannot be applied dynamically at runtime. It will not be rendered as an attribute. Make sure to use the static attribute syntax (\`${key}={value}\`) instead of the dynamic spread syntax (\`{...{ "${key}": value }}\`).`); return ""; } if (key === "class:list") { const listValue = toAttributeString(serializeListValue(value), shouldEscape); if (listValue === "") { return ""; } return markHTMLString(` ${key.slice(0, -5)}="${listValue}"`); } if (key === "style" && !(value instanceof HTMLString)) { if (Array.isArray(value) && value.length === 2) { return markHTMLString( ` ${key}="${toAttributeString(`${toStyleString(value[0])};${value[1]}`, shouldEscape)}"` ); } if (typeof value === "object") { return markHTMLString(` ${key}="${toAttributeString(toStyleString(value), shouldEscape)}"`); } } if (key === "className") { return markHTMLString(` class="${toAttributeString(value, shouldEscape)}"`); } if (value === true && (key.startsWith("data-") || htmlBooleanAttributes.test(key))) { return markHTMLString(` ${key}`); } else { return markHTMLString(` ${key}="${toAttributeString(value, shouldEscape)}"`); } } function internalSpreadAttributes(values, shouldEscape = true) { let output = ""; for (const [key, value] of Object.entries(values)) { output += addAttribute(value, key, shouldEscape); } return markHTMLString(output); } function renderElement$1(name, { props: _props, children = "" }, shouldEscape = true) { const { lang: _, "data-astro-id": astroId, "define:vars": defineVars, ...props } = _props; if (defineVars) { if (name === "style") { delete props["is:global"]; delete props["is:scoped"]; } if (name === "script") { delete props.hoist; children = defineScriptVars(defineVars) + "\n" + children; } } if ((children == null || children == "") && voidElementNames.test(name)) { return `<${name}${internalSpreadAttributes(props, shouldEscape)} />`; } return `<${name}${internalSpreadAttributes(props, shouldEscape)}>${children}`; } const uniqueElements = (item, index, all) => { const props = JSON.stringify(item.props); const children = item.children; return index === all.findIndex((i) => JSON.stringify(i.props) === props && i.children == children); }; function renderAllHeadContent(result) { result._metadata.hasRenderedHead = true; const styles = Array.from(result.styles).filter(uniqueElements).map( (style) => style.props.rel === "stylesheet" ? renderElement$1("link", style) : renderElement$1("style", style) ); result.styles.clear(); const scripts = Array.from(result.scripts).filter(uniqueElements).map((script) => { return renderElement$1("script", script, false); }); const links = Array.from(result.links).filter(uniqueElements).map((link) => renderElement$1("link", link, false)); let content = links.join("\n") + styles.join("\n") + scripts.join("\n"); if (result._metadata.extraHead.length > 0) { for (const part of result._metadata.extraHead) { content += part; } } return markHTMLString(content); } function* renderHead() { yield { type: "head" }; } function* maybeRenderHead() { yield { type: "maybe-head" }; } const slotString = Symbol.for("astro:slot-string"); class SlotString extends HTMLString { constructor(content, instructions) { super(content); this.instructions = instructions; this[slotString] = true; } } function isSlotString(str) { return !!str[slotString]; } function renderSlot(result, slotted, fallback) { if (!slotted && fallback) { return renderSlot(result, fallback); } return { async render(destination) { await renderChild(destination, typeof slotted === "function" ? slotted(result) : slotted); } }; } async function renderSlotToString(result, slotted, fallback) { let content = ""; let instructions = null; const temporaryDestination = { write(chunk) { if (chunk instanceof Response) return; if (typeof chunk === "object" && "type" in chunk && typeof chunk.type === "string") { if (instructions === null) { instructions = []; } instructions.push(chunk); } else { content += chunkToString(result, chunk); } } }; const renderInstance = renderSlot(result, slotted, fallback); await renderInstance.render(temporaryDestination); return markHTMLString(new SlotString(content, instructions)); } async function renderSlots(result, slots = {}) { let slotInstructions = null; let children = {}; if (slots) { await Promise.all( Object.entries(slots).map( ([key, value]) => renderSlotToString(result, value).then((output) => { if (output.instructions) { if (slotInstructions === null) { slotInstructions = []; } slotInstructions.push(...output.instructions); } children[key] = output; }) ) ); } return { slotInstructions, children }; } const Fragment = Symbol.for("astro:fragment"); const Renderer = Symbol.for("astro:renderer"); new TextEncoder(); const decoder = new TextDecoder(); function stringifyChunk(result, chunk) { if (typeof chunk.type === "string") { const instruction = chunk; switch (instruction.type) { case "directive": { const { hydration } = instruction; let needsHydrationScript = hydration && determineIfNeedsHydrationScript(result); let needsDirectiveScript = hydration && determinesIfNeedsDirectiveScript(result, hydration.directive); let prescriptType = needsHydrationScript ? "both" : needsDirectiveScript ? "directive" : null; if (prescriptType) { let prescripts = getPrescripts(result, prescriptType, hydration.directive); return markHTMLString(prescripts); } else { return ""; } } case "head": { if (result._metadata.hasRenderedHead) { return ""; } return renderAllHeadContent(result); } case "maybe-head": { if (result._metadata.hasRenderedHead || result._metadata.headInTree) { return ""; } return renderAllHeadContent(result); } default: { if (chunk instanceof Response) { return ""; } throw new Error(`Unknown chunk type: ${chunk.type}`); } } } else { if (isSlotString(chunk)) { let out = ""; const c = chunk; if (c.instructions) { for (const instr of c.instructions) { out += stringifyChunk(result, instr); } } out += chunk.toString(); return out; } return chunk.toString(); } } function chunkToString(result, chunk) { if (ArrayBuffer.isView(chunk)) { return decoder.decode(chunk); } else { return stringifyChunk(result, chunk); } } function isRenderInstance(obj) { return !!obj && typeof obj === "object" && "render" in obj && typeof obj.render === "function"; } async function renderChild(destination, child) { child = await child; if (child instanceof SlotString) { destination.write(child); } else if (isHTMLString(child)) { destination.write(child); } else if (Array.isArray(child)) { for (const c of child) { await renderChild(destination, c); } } else if (typeof child === "function") { await renderChild(destination, child()); } else if (typeof child === "string") { destination.write(markHTMLString(escapeHTML(child))); } else if (!child && child !== 0) ; else if (isRenderInstance(child)) { await child.render(destination); } else if (isRenderTemplateResult(child)) { await child.render(destination); } else if (isAstroComponentInstance(child)) { await child.render(destination); } else if (ArrayBuffer.isView(child)) { destination.write(child); } else if (typeof child === "object" && (Symbol.asyncIterator in child || Symbol.iterator in child)) { for await (const value of child) { await renderChild(destination, value); } } else { destination.write(child); } } var _a$1; const astroComponentInstanceSym = Symbol.for("astro.componentInstance"); class AstroComponentInstance { constructor(result, props, slots, factory) { this[_a$1] = true; this.result = result; this.props = props; this.factory = factory; this.slotValues = {}; for (const name in slots) { const value = slots[name](result); this.slotValues[name] = () => value; } } async init(result) { if (this.returnValue !== void 0) return this.returnValue; this.returnValue = this.factory(result, this.props, this.slotValues); return this.returnValue; } async render(destination) { if (this.returnValue === void 0) { await this.init(this.result); } let value = this.returnValue; if (isPromise(value)) { value = await value; } if (isHeadAndContent(value)) { await value.content.render(destination); } else { await renderChild(destination, value); } } } _a$1 = astroComponentInstanceSym; function validateComponentProps(props, displayName) { if (props != null) { for (const prop of Object.keys(props)) { if (prop.startsWith("client:")) { console.warn( `You are attempting to render <${displayName} ${prop} />, but ${displayName} is an Astro component. Astro components do not render in the client and should not have a hydration directive. Please use a framework component for client rendering.` ); } } } } function createAstroComponentInstance(result, displayName, factory, props, slots = {}) { validateComponentProps(props, displayName); const instance = new AstroComponentInstance(result, props, slots, factory); if (isAPropagatingComponent(result, factory) && !result._metadata.propagators.has(factory)) { result._metadata.propagators.set(factory, instance); } return instance; } function isAstroComponentInstance(obj) { return typeof obj === "object" && !!obj[astroComponentInstanceSym]; } var _a; const renderTemplateResultSym = Symbol.for("astro.renderTemplateResult"); class RenderTemplateResult { constructor(htmlParts, expressions) { this[_a] = true; this.htmlParts = htmlParts; this.error = void 0; this.expressions = expressions.map((expression) => { if (isPromise(expression)) { return Promise.resolve(expression).catch((err) => { if (!this.error) { this.error = err; throw err; } }); } return expression; }); } async render(destination) { for (let i = 0; i < this.htmlParts.length; i++) { const html = this.htmlParts[i]; const exp = this.expressions[i]; destination.write(markHTMLString(html)); if (exp || exp === 0) { await renderChild(destination, exp); } } } } _a = renderTemplateResultSym; function isRenderTemplateResult(obj) { return typeof obj === "object" && !!obj[renderTemplateResultSym]; } function renderTemplate(htmlParts, ...expressions) { return new RenderTemplateResult(htmlParts, expressions); } async function renderToString(result, componentFactory, props, children, isPage = false, route) { const templateResult = await callComponentAsTemplateResultOrResponse( result, componentFactory, props, children, route ); if (templateResult instanceof Response) return templateResult; let str = ""; let renderedFirstPageChunk = false; const destination = { write(chunk) { if (isPage && !renderedFirstPageChunk) { renderedFirstPageChunk = true; if (!/" : "\n"; str += doctype; } } if (chunk instanceof Response) return; str += chunkToString(result, chunk); } }; await templateResult.render(destination); return str; } async function callComponentAsTemplateResultOrResponse(result, componentFactory, props, children, route) { const factoryResult = await componentFactory(result, props, children); if (factoryResult instanceof Response) { return factoryResult; } else if (!isRenderTemplateResult(factoryResult)) { throw new AstroError({ ...OnlyResponseCanBeReturned, message: OnlyResponseCanBeReturned.message(route == null ? void 0 : route.route, typeof factoryResult), location: { file: route == null ? void 0 : route.component } }); } return isHeadAndContent(factoryResult) ? factoryResult.content : factoryResult; } function componentIsHTMLElement(Component) { return typeof HTMLElement !== "undefined" && HTMLElement.isPrototypeOf(Component); } async function renderHTMLElement(result, constructor, props, slots) { const name = getHTMLElementName(constructor); let attrHTML = ""; for (const attr in props) { attrHTML += ` ${attr}="${toAttributeString(await props[attr])}"`; } return markHTMLString( `<${name}${attrHTML}>${await renderSlotToString(result, slots == null ? void 0 : slots.default)}` ); } function getHTMLElementName(constructor) { const definedName = customElements.getName(constructor); if (definedName) return definedName; const assignedName = constructor.name.replace(/^HTML|Element$/g, "").replace(/[A-Z]/g, "-$&").toLowerCase().replace(/^-/, "html-"); return assignedName; } const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering"); const rendererAliases = /* @__PURE__ */ new Map([["solid", "solid-js"]]); function guessRenderers(componentUrl) { const extname = componentUrl == null ? void 0 : componentUrl.split(".").pop(); switch (extname) { case "svelte": return ["@astrojs/svelte"]; case "vue": return ["@astrojs/vue"]; case "jsx": case "tsx": return ["@astrojs/react", "@astrojs/preact", "@astrojs/solid-js", "@astrojs/vue (jsx)"]; default: return [ "@astrojs/react", "@astrojs/preact", "@astrojs/solid-js", "@astrojs/vue", "@astrojs/svelte", "@astrojs/lit" ]; } } function isFragmentComponent(Component) { return Component === Fragment; } function isHTMLComponent(Component) { return Component && Component["astro:html"] === true; } const ASTRO_SLOT_EXP = /\<\/?astro-slot\b[^>]*>/g; const ASTRO_STATIC_SLOT_EXP = /\<\/?astro-static-slot\b[^>]*>/g; function removeStaticAstroSlot(html, supportsAstroStaticSlot) { const exp = supportsAstroStaticSlot ? ASTRO_STATIC_SLOT_EXP : ASTRO_SLOT_EXP; return html.replace(exp, ""); } async function renderFrameworkComponent(result, displayName, Component, _props, slots = {}) { var _a, _b, _c; if (!Component && !_props["client:only"]) { throw new Error( `Unable to render ${displayName} because it is ${Component}! Did you forget to import the component or is it possible there is a typo?` ); } const { renderers, clientDirectives } = result; const metadata = { astroStaticSlot: true, displayName }; const { hydration, isPage, props } = extractDirectives(_props, clientDirectives); let html = ""; let attrs = void 0; if (hydration) { metadata.hydrate = hydration.directive; metadata.hydrateArgs = hydration.value; metadata.componentExport = hydration.componentExport; metadata.componentUrl = hydration.componentUrl; } const probableRendererNames = guessRenderers(metadata.componentUrl); const validRenderers = renderers.filter((r) => r.name !== "astro:jsx"); const { children, slotInstructions } = await renderSlots(result, slots); let renderer; if (metadata.hydrate !== "only") { let isTagged = false; try { isTagged = Component && Component[Renderer]; } catch { } if (isTagged) { const rendererName = Component[Renderer]; renderer = renderers.find(({ name }) => name === rendererName); } if (!renderer) { let error; for (const r of renderers) { try { if (await r.ssr.check.call({ result }, Component, props, children)) { renderer = r; break; } } catch (e) { error ??= e; } } if (!renderer && error) { throw error; } } if (!renderer && typeof HTMLElement === "function" && componentIsHTMLElement(Component)) { const output = await renderHTMLElement( result, Component, _props, slots ); return { render(destination) { destination.write(output); } }; } } else { if (metadata.hydrateArgs) { const passedName = metadata.hydrateArgs; const rendererName = rendererAliases.has(passedName) ? rendererAliases.get(passedName) : passedName; renderer = renderers.find( ({ name }) => name === `@astrojs/${rendererName}` || name === rendererName ); } if (!renderer && validRenderers.length === 1) { renderer = validRenderers[0]; } if (!renderer) { const extname = (_a = metadata.componentUrl) == null ? void 0 : _a.split(".").pop(); renderer = renderers.filter( ({ name }) => name === `@astrojs/${extname}` || name === extname )[0]; } } if (!renderer) { if (metadata.hydrate === "only") { throw new AstroError({ ...NoClientOnlyHint, message: NoClientOnlyHint.message(metadata.displayName), hint: NoClientOnlyHint.hint( probableRendererNames.map((r) => r.replace("@astrojs/", "")).join("|") ) }); } else if (typeof Component !== "string") { const matchingRenderers = validRenderers.filter( (r) => probableRendererNames.includes(r.name) ); const plural = validRenderers.length > 1; if (matchingRenderers.length === 0) { throw new AstroError({ ...NoMatchingRenderer, message: NoMatchingRenderer.message( metadata.displayName, (_b = metadata == null ? void 0 : metadata.componentUrl) == null ? void 0 : _b.split(".").pop(), plural, validRenderers.length ), hint: NoMatchingRenderer.hint( formatList(probableRendererNames.map((r) => "`" + r + "`")) ) }); } else if (matchingRenderers.length === 1) { renderer = matchingRenderers[0]; ({ html, attrs } = await renderer.ssr.renderToStaticMarkup.call( { result }, Component, props, children, metadata )); } else { throw new Error(`Unable to render ${metadata.displayName}! This component likely uses ${formatList(probableRendererNames)}, but Astro encountered an error during server-side rendering. Please ensure that ${metadata.displayName}: 1. Does not unconditionally access browser-specific globals like \`window\` or \`document\`. If this is unavoidable, use the \`client:only\` hydration directive. 2. Does not conditionally return \`null\` or \`undefined\` when rendered on the server. If you're still stuck, please open an issue on GitHub or join us at https://astro.build/chat.`); } } } else { if (metadata.hydrate === "only") { html = await renderSlotToString(result, slots == null ? void 0 : slots.fallback); } else { ({ html, attrs } = await renderer.ssr.renderToStaticMarkup.call( { result }, Component, props, children, metadata )); } } if (renderer && !renderer.clientEntrypoint && renderer.name !== "@astrojs/lit" && metadata.hydrate) { throw new AstroError({ ...NoClientEntrypoint, message: NoClientEntrypoint.message( displayName, metadata.hydrate, renderer.name ) }); } if (!html && typeof Component === "string") { const Tag = sanitizeElementName(Component); const childSlots = Object.values(children).join(""); const renderTemplateResult = renderTemplate`<${Tag}${internalSpreadAttributes( props )}${markHTMLString( childSlots === "" && voidElementNames.test(Tag) ? `/>` : `>${childSlots}` )}`; html = ""; const destination = { write(chunk) { if (chunk instanceof Response) return; html += chunkToString(result, chunk); } }; await renderTemplateResult.render(destination); } if (!hydration) { return { render(destination) { var _a2; if (slotInstructions) { for (const instruction of slotInstructions) { destination.write(instruction); } } if (isPage || (renderer == null ? void 0 : renderer.name) === "astro:jsx") { destination.write(html); } else if (html && html.length > 0) { destination.write( markHTMLString( removeStaticAstroSlot(html, ((_a2 = renderer == null ? void 0 : renderer.ssr) == null ? void 0 : _a2.supportsAstroStaticSlot) ?? false) ) ); } } }; } const astroId = shorthash( ` ${html} ${serializeProps( props, metadata )}` ); const island = await generateHydrateScript( { renderer, result, astroId, props, attrs }, metadata ); let unrenderedSlots = []; if (html) { if (Object.keys(children).length > 0) { for (const key of Object.keys(children)) { let tagName = ((_c = renderer == null ? void 0 : renderer.ssr) == null ? void 0 : _c.supportsAstroStaticSlot) ? !!metadata.hydrate ? "astro-slot" : "astro-static-slot" : "astro-slot"; let expectedHTML = key === "default" ? `<${tagName}>` : `<${tagName} name="${key}">`; if (!html.includes(expectedHTML)) { unrenderedSlots.push(key); } } } } else { unrenderedSlots = Object.keys(children); } const template = unrenderedSlots.length > 0 ? unrenderedSlots.map( (key) => `` ).join("") : ""; island.children = `${html ?? ""}${template}`; if (island.children) { island.props["await-children"] = ""; } return { render(destination) { if (slotInstructions) { for (const instruction of slotInstructions) { destination.write(instruction); } } destination.write({ type: "directive", hydration }); destination.write(markHTMLString(renderElement$1("astro-island", island, false))); } }; } function sanitizeElementName(tag) { const unsafe = /[&<>'"\s]+/g; if (!unsafe.test(tag)) return tag; return tag.trim().split(unsafe)[0].trim(); } async function renderFragmentComponent(result, slots = {}) { const children = await renderSlotToString(result, slots == null ? void 0 : slots.default); return { render(destination) { if (children == null) return; destination.write(children); } }; } async function renderHTMLComponent(result, Component, _props, slots = {}) { const { slotInstructions, children } = await renderSlots(result, slots); const html = Component({ slots: children }); const hydrationHtml = slotInstructions ? slotInstructions.map((instr) => chunkToString(result, instr)).join("") : ""; return { render(destination) { destination.write(markHTMLString(hydrationHtml + html)); } }; } function renderAstroComponent(result, displayName, Component, props, slots = {}) { const instance = createAstroComponentInstance(result, displayName, Component, props, slots); const bufferChunks = []; const bufferDestination = { write: (chunk) => bufferChunks.push(chunk) }; const renderPromise = instance.render(bufferDestination); return { async render(destination) { for (const chunk of bufferChunks) { destination.write(chunk); } bufferChunks.length = 0; bufferDestination.write = (chunk) => destination.write(chunk); await renderPromise; } }; } async function renderComponent(result, displayName, Component, props, slots = {}) { if (isPromise(Component)) { Component = await Component; } if (isFragmentComponent(Component)) { return await renderFragmentComponent(result, slots); } if (isHTMLComponent(Component)) { return await renderHTMLComponent(result, Component, props, slots); } if (isAstroComponentFactory(Component)) { return renderAstroComponent(result, displayName, Component, props, slots); } return await renderFrameworkComponent(result, displayName, Component, props, slots); } async function renderComponentToString(result, displayName, Component, props, slots = {}, isPage = false, route) { let str = ""; let renderedFirstPageChunk = false; let head = ""; if (nonAstroPageNeedsHeadInjection(Component)) { for (const headChunk of maybeRenderHead()) { head += chunkToString(result, headChunk); } } try { const destination = { write(chunk) { if (isPage && !renderedFirstPageChunk) { renderedFirstPageChunk = true; if (!/" : "\n"; str += doctype + head; } } if (chunk instanceof Response) return; str += chunkToString(result, chunk); } }; const renderInstance = await renderComponent(result, displayName, Component, props, slots); await renderInstance.render(destination); } catch (e) { if (AstroError.is(e) && !e.loc) { e.setLocation({ file: route == null ? void 0 : route.component }); } throw e; } return str; } function nonAstroPageNeedsHeadInjection(pageComponent) { return !!(pageComponent == null ? void 0 : pageComponent[needsHeadRenderingSymbol]); } const ClientOnlyPlaceholder = "astro-client-only"; class Skip { constructor(vnode) { this.vnode = vnode; this.count = 0; } increment() { this.count++; } haveNoTried() { return this.count === 0; } isCompleted() { return this.count > 2; } } Skip.symbol = Symbol("astro:jsx:skip"); let originalConsoleError; let consoleFilterRefs = 0; async function renderJSX(result, vnode) { switch (true) { case vnode instanceof HTMLString: if (vnode.toString().trim() === "") { return ""; } return vnode; case typeof vnode === "string": return markHTMLString(escapeHTML(vnode)); case typeof vnode === "function": return vnode; case (!vnode && vnode !== 0): return ""; case Array.isArray(vnode): return markHTMLString( (await Promise.all(vnode.map((v) => renderJSX(result, v)))).join("") ); } let skip; if (vnode.props) { if (vnode.props[Skip.symbol]) { skip = vnode.props[Skip.symbol]; } else { skip = new Skip(vnode); } } else { skip = new Skip(vnode); } return renderJSXVNode(result, vnode, skip); } async function renderJSXVNode(result, vnode, skip) { if (isVNode(vnode)) { switch (true) { case !vnode.type: { throw new Error(`Unable to render ${result.pathname} because it contains an undefined Component! Did you forget to import the component or is it possible there is a typo?`); } case vnode.type === Symbol.for("astro:fragment"): return renderJSX(result, vnode.props.children); case vnode.type.isAstroComponentFactory: { let props = {}; let slots = {}; for (const [key, value] of Object.entries(vnode.props ?? {})) { if (key === "children" || value && typeof value === "object" && value["$$slot"]) { slots[key === "children" ? "default" : key] = () => renderJSX(result, value); } else { props[key] = value; } } const str = await renderToString(result, vnode.type, props, slots); if (str instanceof Response) { throw str; } const html = markHTMLString(str); return html; } case (!vnode.type && vnode.type !== 0): return ""; case (typeof vnode.type === "string" && vnode.type !== ClientOnlyPlaceholder): return markHTMLString(await renderElement(result, vnode.type, vnode.props ?? {})); } if (vnode.type) { let extractSlots2 = function(child) { if (Array.isArray(child)) { return child.map((c) => extractSlots2(c)); } if (!isVNode(child)) { _slots.default.push(child); return; } if ("slot" in child.props) { _slots[child.props.slot] = [..._slots[child.props.slot] ?? [], child]; delete child.props.slot; return; } _slots.default.push(child); }; if (typeof vnode.type === "function" && vnode.type["astro:renderer"]) { skip.increment(); } if (typeof vnode.type === "function" && vnode.props["server:root"]) { const output2 = await vnode.type(vnode.props ?? {}); return await renderJSX(result, output2); } if (typeof vnode.type === "function") { if (skip.haveNoTried() || skip.isCompleted()) { useConsoleFilter(); try { const output2 = await vnode.type(vnode.props ?? {}); let renderResult; if (output2 == null ? void 0 : output2[AstroJSX]) { renderResult = await renderJSXVNode(result, output2, skip); return renderResult; } else if (!output2) { renderResult = await renderJSXVNode(result, output2, skip); return renderResult; } } catch (e) { if (skip.isCompleted()) { throw e; } skip.increment(); } finally { finishUsingConsoleFilter(); } } else { skip.increment(); } } const { children = null, ...props } = vnode.props ?? {}; const _slots = { default: [] }; extractSlots2(children); for (const [key, value] of Object.entries(props)) { if (value["$$slot"]) { _slots[key] = value; delete props[key]; } } const slotPromises = []; const slots = {}; for (const [key, value] of Object.entries(_slots)) { slotPromises.push( renderJSX(result, value).then((output2) => { if (output2.toString().trim().length === 0) return; slots[key] = () => output2; }) ); } await Promise.all(slotPromises); props[Skip.symbol] = skip; let output; if (vnode.type === ClientOnlyPlaceholder && vnode.props["client:only"]) { output = await renderComponentToString( result, vnode.props["client:display-name"] ?? "", null, props, slots ); } else { output = await renderComponentToString( result, typeof vnode.type === "function" ? vnode.type.name : vnode.type, vnode.type, props, slots ); } return markHTMLString(output); } } return markHTMLString(`${vnode}`); } async function renderElement(result, tag, { children, ...props }) { return markHTMLString( `<${tag}${spreadAttributes(props)}${markHTMLString( (children == null || children == "") && voidElementNames.test(tag) ? `/>` : `>${children == null ? "" : await renderJSX(result, prerenderElementChildren(tag, children))}` )}` ); } function prerenderElementChildren(tag, children) { if (typeof children === "string" && (tag === "style" || tag === "script")) { return markHTMLString(children); } else { return children; } } function useConsoleFilter() { consoleFilterRefs++; if (!originalConsoleError) { originalConsoleError = console.error; try { console.error = filteredConsoleError; } catch (error) { } } } function finishUsingConsoleFilter() { consoleFilterRefs--; } function filteredConsoleError(msg, ...rest) { if (consoleFilterRefs > 0 && typeof msg === "string") { const isKnownReactHookError = msg.includes("Warning: Invalid hook call.") && msg.includes("https://reactjs.org/link/invalid-hook-call"); if (isKnownReactHookError) return; } originalConsoleError(msg, ...rest); } typeof process === "object" && Object.prototype.toString.call(process) === "[object process]"; function spreadAttributes(values = {}, _name, { class: scopedClassName } = {}) { let output = ""; if (scopedClassName) { if (typeof values.class !== "undefined") { values.class += ` ${scopedClassName}`; } else if (typeof values["class:list"] !== "undefined") { values["class:list"] = [values["class:list"], scopedClassName]; } else { values.class = scopedClassName; } } for (const [key, value] of Object.entries(values)) { output += addAttribute(value, key, true); } return markHTMLString(output); } const AstroJSX = "astro:jsx"; const Empty = Symbol("empty"); const toSlotName = (slotAttr) => slotAttr; function isVNode(vnode) { return vnode && typeof vnode === "object" && vnode[AstroJSX]; } function transformSlots(vnode) { if (typeof vnode.type === "string") return vnode; const slots = {}; if (isVNode(vnode.props.children)) { const child = vnode.props.children; if (!isVNode(child)) return; if (!("slot" in child.props)) return; const name = toSlotName(child.props.slot); slots[name] = [child]; slots[name]["$$slot"] = true; delete child.props.slot; delete vnode.props.children; } if (Array.isArray(vnode.props.children)) { vnode.props.children = vnode.props.children.map((child) => { if (!isVNode(child)) return child; if (!("slot" in child.props)) return child; const name = toSlotName(child.props.slot); if (Array.isArray(slots[name])) { slots[name].push(child); } else { slots[name] = [child]; slots[name]["$$slot"] = true; } delete child.props.slot; return Empty; }).filter((v) => v !== Empty); } Object.assign(vnode.props, slots); } function markRawChildren(child) { if (typeof child === "string") return markHTMLString(child); if (Array.isArray(child)) return child.map((c) => markRawChildren(c)); return child; } function transformSetDirectives(vnode) { if (!("set:html" in vnode.props || "set:text" in vnode.props)) return; if ("set:html" in vnode.props) { const children = markRawChildren(vnode.props["set:html"]); delete vnode.props["set:html"]; Object.assign(vnode.props, { children }); return; } if ("set:text" in vnode.props) { const children = vnode.props["set:text"]; delete vnode.props["set:text"]; Object.assign(vnode.props, { children }); return; } } function createVNode(type, props) { const vnode = { [Renderer]: "astro:jsx", [AstroJSX]: true, type, props: props ?? {} }; transformSetDirectives(vnode); transformSlots(vnode); return vnode; } const slotName = (str) => str.trim().replace(/[-_]([a-z])/g, (_, w) => w.toUpperCase()); async function check(Component, props, { default: children = null, ...slotted } = {}) { if (typeof Component !== "function") return false; const slots = {}; for (const [key, value] of Object.entries(slotted)) { const name = slotName(key); slots[name] = value; } try { const result = await Component({ ...props, ...slots, children }); return result[AstroJSX]; } catch (e) { const error = e; if (Component[Symbol.for("mdx-component")]) { throw createFormattedError({ message: error.message, title: error.name, hint: `This issue often occurs when your MDX component encounters runtime errors.`, name: error.name, stack: error.stack }); } } return false; } async function renderToStaticMarkup(Component, props = {}, { default: children = null, ...slotted } = {}) { const slots = {}; for (const [key, value] of Object.entries(slotted)) { const name = slotName(key); slots[name] = value; } const { result } = this; const html = await renderJSX(result, createVNode(Component, { ...props, ...slots, children })); return { html }; } function createFormattedError({ message, name, stack, hint }) { const error = new Error(message); error.name = name; error.stack = stack; error.hint = hint; return error; } var server_default = { check, renderToStaticMarkup }; export { Fragment as F, createComponent as a, addAttribute as b, createAstro as c, renderHead as d, renderSlot as e, renderComponent as f, createVNode as g, server_default as h, maybeRenderHead as m, renderTemplate as r, spreadAttributes as s };