@buildappolis/env-manager
Version:
Enterprise-grade environment variable management system with encryption, snapshots, and validation
1,308 lines (1,272 loc) • 87.4 kB
JavaScript
import { A as AstroError, E as EndpointDidNotReturnAResponse, I as InvalidComponentArgs, a as AstroGlobUsedOutside, b as AstroGlobNoMatch, M as MissingMediaQueryDirective, N as NoMatchingImport, O as OnlyResponseCanBeReturned, R as ResponseSentError, c as NoMatchingRenderer, d as NoClientOnlyHint, e as NoClientEntrypoint } from './assets-service_DpLAZY03.mjs';
import { clsx } from 'clsx';
const ASTRO_VERSION = "4.16.18";
const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";
const NOOP_MIDDLEWARE_HEADER = "X-Astro-Noop";
const ROUTE_TYPE_HEADER = "X-Astro-Route-Type";
const DEFAULT_404_COMPONENT = "astro-default-404.astro";
const REROUTABLE_STATUS_CODES = [404, 500];
const clientAddressSymbol = Symbol.for("astro.clientAddress");
const clientLocalsSymbol = Symbol.for("astro.locals");
const originPathnameSymbol = Symbol.for("astro.originPathname");
const responseSentSymbol = Symbol.for("astro.responseSent");
function getDefaultExportFromCjs (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
let FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM, isTTY=true;
if (typeof process !== 'undefined') {
({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
isTTY = process.stdout && process.stdout.isTTY;
}
const $ = {
enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== 'dumb' && (
FORCE_COLOR != null && FORCE_COLOR !== '0' || isTTY
)
};
function init(x, y) {
let rgx = new RegExp(`\\x1b\\[${y}m`, 'g');
let open = `\x1b[${x}m`, close = `\x1b[${y}m`;
return function (txt) {
if (!$.enabled || txt == null) return txt;
return open + (!!~(''+txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
};
}
const bold = init(1, 22);
const dim = init(2, 22);
const red = init(31, 39);
const yellow = init(33, 39);
const blue = init(34, 39);
async function renderEndpoint(mod, context, ssr, logger) {
const { request, url } = context;
const method = request.method.toUpperCase();
const handler = mod[method] ?? mod["ALL"];
if (!ssr && ssr === false && method !== "GET") {
logger.warn(
"router",
`${url.pathname} ${bold(
method
)} requests are not available for a static site. Update your config to \`output: 'server'\` or \`output: 'hybrid'\` to enable.`
);
}
if (handler === void 0) {
logger.warn(
"router",
`No API Route handler exists for the method "${method}" for the route "${url.pathname}".
Found handlers: ${Object.keys(mod).map((exp) => JSON.stringify(exp)).join(", ")}
` + ("all" in mod ? `One of the exported handlers is "all" (lowercase), did you mean to export 'ALL'?
` : "")
);
return new Response(null, { status: 404 });
}
if (typeof handler !== "function") {
logger.error(
"router",
`The route "${url.pathname}" exports a value for the method "${method}", but it is of the type ${typeof handler} instead of a function.`
);
return new Response(null, { status: 500 });
}
let response = await handler.call(mod, context);
if (!response || response instanceof Response === false) {
throw new AstroError(EndpointDidNotReturnAResponse);
}
if (REROUTABLE_STATUS_CODES.includes(response.status)) {
try {
response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
} catch (err) {
if (err.message?.includes("immutable")) {
response = new Response(response.body, response);
response.headers.set(REROUTE_DIRECTIVE_HEADER, "no");
} else {
throw err;
}
}
}
return response;
}
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) {
const name = moduleId?.split("/").pop()?.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);
}
}
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 {
// TODO: this is no longer necessary for `Astro.site`
// but it somehow allows working around caching issues in content collections for some tests
site: void 0,
generator: `Astro v${ASTRO_VERSION}`,
glob: createAstroGlobFn()
};
}
/**
* Copyright (C) 2017-present by Andrea Giammarchi - @WebReflection
*
* 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 {replace} = '';
const ca = /[&<>'"]/g;
const esca = {
'&': '&',
'<': '<',
'>': '>',
"'": ''',
'"': '"'
};
const pe = m => esca[m];
/**
* Safely escape HTML entities such as `&`, `<`, `>`, `"`, and `'`.
* @param {string} es the input to safely escape
* @returns {string} the escaped input, and it **throws** an error if
* the input type is unexpected, except for boolean and numbers,
* converted as string.
*/
const escape = es => replace.call(es, ca, pe);
function isPromise(value) {
return !!value && typeof value === "object" && "then" in value && typeof value.then === "function";
}
async function* streamAsyncIterator(stream) {
const reader = stream.getReader();
try {
while (true) {
const { done, value } = await reader.read();
if (done) return;
yield value;
}
} finally {
reader.releaseLock();
}
}
const escapeHTML = escape;
class HTMLBytes extends Uint8Array {
}
Object.defineProperty(HTMLBytes.prototype, Symbol.toStringTag, {
get() {
return "HTMLBytes";
}
});
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]";
}
function markHTMLBytes(bytes) {
return new HTMLBytes(bytes);
}
function hasGetReader(obj) {
return typeof obj.getReader === "function";
}
async function* unescapeChunksAsync(iterable) {
if (hasGetReader(iterable)) {
for await (const chunk of streamAsyncIterator(iterable)) {
yield unescapeHTML(chunk);
}
} else {
for await (const chunk of iterable) {
yield unescapeHTML(chunk);
}
}
}
function* unescapeChunks(iterable) {
for (const chunk of iterable) {
yield unescapeHTML(chunk);
}
}
function unescapeHTML(str) {
if (!!str && typeof str === "object") {
if (str instanceof Uint8Array) {
return markHTMLBytes(str);
} else if (str instanceof Response && str.body) {
const body = str.body;
return unescapeChunksAsync(body);
} else if (typeof str.then === "function") {
return Promise.resolve(str).then((value) => {
return unescapeHTML(value);
});
} else if (str[Symbol.for("astro:slot-string")]) {
return str;
} else if (Symbol.iterator in str) {
return unescapeChunks(str);
} else if (Symbol.asyncIterator in str || hasGetReader(str)) {
return unescapeChunksAsync(str);
}
}
return markHTMLString(str);
}
const AstroJSX = "astro:jsx";
function isVNode(vnode) {
return vnode && typeof vnode === "object" && vnode[AstroJSX];
}
const RenderInstructionSymbol = Symbol.for("astro:render");
function createRenderInstruction(instruction) {
return Object.defineProperty(instruction, RenderInstructionSymbol, {
value: true
});
}
function isRenderInstruction(chunk) {
return chunk && typeof chunk === "object" && chunk[RenderInstructionSymbol];
}
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,
Infinity: 11
};
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)];
}
if (value === Infinity) {
return [PROP_TYPE.Infinity, 1];
}
if (value === -Infinity) {
return [PROP_TYPE.Infinity, -1];
}
if (value === void 0) {
return [PROP_TYPE.Value];
}
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",
"data-astro-transition-persist-props"
]);
function extractDirectives(inputProps, clientDirectives) {
let extracted = {
isPage: false,
hydration: null,
props: {},
propsWithoutTransitionAttributes: {}
};
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 {
extracted.props[key] = value;
if (!transitionDirectivesToCopyOnIsland.includes(key)) {
extracted.propsWithoutTransitionAttributes[key] = value;
}
}
}
for (const sym of Object.getOwnPropertySymbols(inputProps)) {
extracted.props[sym] = inputProps[sym];
extracted.propsWithoutTransitionAttributes[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 AstroError({
...NoMatchingImport,
message: NoMatchingImport.message(metadata.displayName)
});
}
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 (typeof props[name] !== "undefined") {
island.props[name] = props[name];
}
});
return island;
}
/**
* shortdash - https://github.com/bibig/node-shorthash
*
* @license
*
* (The MIT License)
*
* Copyright (c) 2013 Bibig <bibig@me.com>
*
* 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 !== null && !!obj[headAndContentSym];
}
var astro_island_prebuilt_dev_default = `(()=>{var A=Object.defineProperty;var g=(i,o,a)=>o in i?A(i,o,{enumerable:!0,configurable:!0,writable:!0,value:a}):i[o]=a;var l=(i,o,a)=>g(i,typeof o!="symbol"?o+"":o,a);{let i={0:t=>y(t),1:t=>a(t),2:t=>new RegExp(t),3:t=>new Date(t),4:t=>new Map(a(t)),5:t=>new Set(a(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),11:t=>1/0*t},o=t=>{let[h,e]=t;return h in i?i[h](e):void 0},a=t=>t.map(o),y=t=>typeof t!="object"||t===null?t:Object.fromEntries(Object.entries(t).map(([h,e])=>[h,o(e)]));class f extends HTMLElement{constructor(){super(...arguments);l(this,"Component");l(this,"hydrator");l(this,"hydrate",async()=>{var b;if(!this.hydrator||!this.isConnected)return;let e=(b=this.parentElement)==null?void 0:b.closest("astro-island[ssr]");if(e){e.addEventListener("astro:hydrate",this.hydrate,{once:!0});return}let c=this.querySelectorAll("astro-slot"),n={},p=this.querySelectorAll("template[data-astro-template]");for(let r of p){let s=r.closest(this.tagName);s!=null&&s.isSameNode(this)&&(n[r.getAttribute("data-astro-template")||"default"]=r.innerHTML,r.remove())}for(let r of c){let s=r.closest(this.tagName);s!=null&&s.isSameNode(this)&&(n[r.getAttribute("name")||"default"]=r.innerHTML)}let u;try{u=this.hasAttribute("props")?y(JSON.parse(this.getAttribute("props"))):{}}catch(r){let s=this.getAttribute("component-url")||"<unknown>",v=this.getAttribute("component-export");throw v&&(s+=\` (export \${v})\`),console.error(\`[hydrate] Error parsing props for component \${s}\`,this.getAttribute("props"),r),r}let d,m=this.hydrator(this);d=performance.now(),await m(this.Component,u,n,{client:this.getAttribute("client")}),d&&this.setAttribute("client-render-time",(performance.now()-d).toString()),this.removeAttribute("ssr"),this.dispatchEvent(new CustomEvent("astro:hydrate"))});l(this,"unmount",()=>{this.isConnected||this.dispatchEvent(new CustomEvent("astro:unmount"))})}disconnectedCallback(){document.removeEventListener("astro:after-swap",this.unmount),document.addEventListener("astro:after-swap",this.unmount,{once:!0})}connectedCallback(){if(!this.hasAttribute("await-children")||document.readyState==="interactive"||document.readyState==="complete")this.childrenConnectedCallback();else{let e=()=>{document.removeEventListener("DOMContentLoaded",e),c.disconnect(),this.childrenConnectedCallback()},c=new MutationObserver(()=>{var n;((n=this.lastChild)==null?void 0:n.nodeType)===Node.COMMENT_NODE&&this.lastChild.nodeValue==="astro:end"&&(this.lastChild.remove(),e())});c.observe(this,{childList:!0}),document.addEventListener("DOMContentLoaded",e)}}async childrenConnectedCallback(){let e=this.getAttribute("before-hydration-url");e&&await import(e),this.start()}async start(){let e=JSON.parse(this.getAttribute("opts")),c=this.getAttribute("client");if(Astro[c]===void 0){window.addEventListener(\`astro:\${c}\`,()=>this.start(),{once:!0});return}try{await Astro[c](async()=>{let n=this.getAttribute("renderer-url"),[p,{default:u}]=await Promise.all([import(this.getAttribute("component-url")),n?import(n):()=>()=>{}]),d=this.getAttribute("component-export")||"default";if(!d.includes("."))this.Component=p[d];else{this.Component=p;for(let m of d.split("."))this.Component=this.Component[m]}return this.hydrator=u,this.hydrate},e,this)}catch(n){console.error(\`[astro-island] Error hydrating \${this.getAttribute("component-url")}\`,n)}}attributeChangedCallback(){this.hydrate()}}l(f,"observedAttributes",["props"]),customElements.get("astro-island")||customElements.define("astro-island",f)}})();`;
var astro_island_prebuilt_default = `(()=>{var A=Object.defineProperty;var g=(i,o,a)=>o in i?A(i,o,{enumerable:!0,configurable:!0,writable:!0,value:a}):i[o]=a;var d=(i,o,a)=>g(i,typeof o!="symbol"?o+"":o,a);{let i={0:t=>m(t),1:t=>a(t),2:t=>new RegExp(t),3:t=>new Date(t),4:t=>new Map(a(t)),5:t=>new Set(a(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),11:t=>1/0*t},o=t=>{let[l,e]=t;return l in i?i[l](e):void 0},a=t=>t.map(o),m=t=>typeof t!="object"||t===null?t:Object.fromEntries(Object.entries(t).map(([l,e])=>[l,o(e)]));class y extends HTMLElement{constructor(){super(...arguments);d(this,"Component");d(this,"hydrator");d(this,"hydrate",async()=>{var b;if(!this.hydrator||!this.isConnected)return;let e=(b=this.parentElement)==null?void 0:b.closest("astro-island[ssr]");if(e){e.addEventListener("astro:hydrate",this.hydrate,{once:!0});return}let c=this.querySelectorAll("astro-slot"),n={},h=this.querySelectorAll("template[data-astro-template]");for(let r of h){let s=r.closest(this.tagName);s!=null&&s.isSameNode(this)&&(n[r.getAttribute("data-astro-template")||"default"]=r.innerHTML,r.remove())}for(let r of c){let s=r.closest(this.tagName);s!=null&&s.isSameNode(this)&&(n[r.getAttribute("name")||"default"]=r.innerHTML)}let p;try{p=this.hasAttribute("props")?m(JSON.parse(this.getAttribute("props"))):{}}catch(r){let s=this.getAttribute("component-url")||"<unknown>",v=this.getAttribute("component-export");throw v&&(s+=\` (export \${v})\`),console.error(\`[hydrate] Error parsing props for component \${s}\`,this.getAttribute("props"),r),r}let u;await this.hydrator(this)(this.Component,p,n,{client:this.getAttribute("client")}),this.removeAttribute("ssr"),this.dispatchEvent(new CustomEvent("astro:hydrate"))});d(this,"unmount",()=>{this.isConnected||this.dispatchEvent(new CustomEvent("astro:unmount"))})}disconnectedCallback(){document.removeEventListener("astro:after-swap",this.unmount),document.addEventListener("astro:after-swap",this.unmount,{once:!0})}connectedCallback(){if(!this.hasAttribute("await-children")||document.readyState==="interactive"||document.readyState==="complete")this.childrenConnectedCallback();else{let e=()=>{document.removeEventListener("DOMContentLoaded",e),c.disconnect(),this.childrenConnectedCallback()},c=new MutationObserver(()=>{var n;((n=this.lastChild)==null?void 0:n.nodeType)===Node.COMMENT_NODE&&this.lastChild.nodeValue==="astro:end"&&(this.lastChild.remove(),e())});c.observe(this,{childList:!0}),document.addEventListener("DOMContentLoaded",e)}}async childrenConnectedCallback(){let e=this.getAttribute("before-hydration-url");e&&await import(e),this.start()}async start(){let e=JSON.parse(this.getAttribute("opts")),c=this.getAttribute("client");if(Astro[c]===void 0){window.addEventListener(\`astro:\${c}\`,()=>this.start(),{once:!0});return}try{await Astro[c](async()=>{let n=this.getAttribute("renderer-url"),[h,{default:p}]=await Promise.all([import(this.getAttribute("component-url")),n?import(n):()=>()=>{}]),u=this.getAttribute("component-export")||"default";if(!u.includes("."))this.Component=h[u];else{this.Component=h;for(let f of u.split("."))this.Component=this.Component[f]}return this.hydrator=p,this.hydrate},e,this)}catch(n){console.error(\`[astro-island] Error hydrating \${this.getAttribute("component-url")}\`,n)}}attributeChangedCallback(){this.hydrate()}}d(y,"observedAttributes",["props"]),customElements.get("astro-island")||customElements.define("astro-island",y)}})();`;
const ISLAND_STYLES = `<style>astro-island,astro-slot,astro-static-slot{display:contents}</style>`;
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}<script>${getDirectiveScriptText(result, directive)};${process.env.NODE_ENV === "development" ? astro_island_prebuilt_dev_default : astro_island_prebuilt_default}</script>`;
case "directive":
return `<script>${getDirectiveScriptText(result, directive)}</script>`;
}
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|checked|controls|default|defer|disabled|disablepictureinpicture|disableremoteplayback|formnovalidate|hidden|loop|nomodule|novalidate|open|playsinline|readonly|required|reversed|scoped|seamless|selected|itemscope)$/i;
const htmlEnumAttributes = /^(?:contenteditable|draggable|spellcheck|value)$/i;
const svgEnumAttributes = /^(?:autoReverse|externalResourcesRequired|focusable|preserveAlpha)$/i;
const AMPERSAND_REGEX = /&/g;
const DOUBLE_QUOTE_REGEX = /"/g;
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/.test(match)) return "";
return index === 0 ? match : match.toUpperCase();
});
const toAttributeString = (value, shouldEscape = true) => shouldEscape ? String(value).replace(AMPERSAND_REGEX, "&").replace(DOUBLE_QUOTE_REGEX, """) : value;
const kebab = (k) => k.toLowerCase() === k ? k : k.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
const toStyleString = (obj) => Object.entries(obj).filter(([_, v]) => typeof v === "string" && v.trim() || typeof v === "number").map(([k, v]) => {
if (k[0] !== "-" && k[1] !== "-") return `${kebab(k)}:${v}`;
return `${k}:${v}`;
}).join(";");
function defineScriptVars(vars) {
let output = "";
for (const [key, value] of Object.entries(vars)) {
output += `const ${toIdent(key)} = ${JSON.stringify(value)?.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(clsx(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 (typeof value === "string" && value.includes("&") && isHttpUrl(value)) {
return markHTMLString(` ${key}="${toAttributeString(value, false)}"`);
}
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}</${name}>`;
}
const noop = () => {
};
class BufferedRenderer {
chunks = [];
renderPromise;
destination;
constructor(bufferRenderFunction) {
this.renderPromise = bufferRenderFunction(this);
Promise.resolve(this.renderPromise).catch(noop);
}
write(chunk) {
if (this.destination) {
this.destination.write(chunk);
} else {
this.chunks.push(chunk);
}
}
async renderToFinalDestination(destination) {
for (const chunk of this.chunks) {
destination.write(chunk);
}
this.destination = destination;
await this.renderPromise;
}
}
function renderToBufferDestination(bufferRenderFunction) {
const renderer = new BufferedRenderer(bufferRenderFunction);
return renderer;
}
const isNode = typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]";
const isDeno = typeof Deno !== "undefined";
function promiseWithResolvers() {
let resolve, reject;
const promise = new Promise((_resolve, _reject) => {
resolve = _resolve;
reject = _reject;
});
return {
promise,
resolve,
reject
};
}
const VALID_PROTOCOLS = ["http:", "https:"];
function isHttpUrl(url) {
try {
const parsedUrl = new URL(url);
return VALID_PROTOCOLS.includes(parsedUrl.protocol);
} catch {
return false;
}
}
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 = styles.join("\n") + links.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() {
return createRenderInstruction({ type: "head" });
}
function maybeRenderHead() {
return createRenderInstruction({ type: "maybe-head" });
}
const renderTemplateResultSym = Symbol.for("astro.renderTemplateResult");
class RenderTemplateResult {
[renderTemplateResultSym] = true;
htmlParts;
expressions;
error;
constructor(htmlParts, expressions) {
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) {
const expRenders = this.expressions.map((exp) => {
return renderToBufferDestination((bufferDestination) => {
if (exp || exp === 0) {
return renderChild(bufferDestination, exp);
}
});
});
for (let i = 0; i < this.htmlParts.length; i++) {
const html = this.htmlParts[i];
const expRender = expRenders[i];
destination.write(markHTMLString(html));
if (expRender) {
await expRender.renderToFinalDestination(destination);
}
}
}
}
function isRenderTemplateResult(obj) {
return typeof obj === "object" && obj !== null && !!obj[renderTemplateResultSym];
}
function renderTemplate(htmlParts, ...expressions) {
return new RenderTemplateResult(htmlParts, expressions);
}
const slotString = Symbol.for("astro:slot-string");
class SlotString extends HTMLString {
instructions;
[slotString];
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 SlotString) {
content += chunk;
if (chunk.instructions) {
instructions ??= [];
instructions.push(...chunk.instructions);
}
} else if (chunk instanceof Response) return;
else 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 };
}
function createSlotValueFromString(content) {
return function() {
return renderTemplate`${unescapeHTML(content)}`;
};
}
const Fragment = Symbol.for("astro:fragment");
const Renderer = Symbol.for("astro:renderer");
const encoder$1 = new TextEncoder();
const decoder$1 = new TextDecoder();
function stringifyChunk(result, chunk) {
if (isRenderInstruction(chunk)) {
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 || result.partial) {
return "";
}
return renderAllHeadContent(result);
}
case "maybe-head": {
if (result._metadata.hasRenderedHead || result._metadata.headInTree || result.partial) {
return "";
}
return renderAllHeadContent(result);
}
case "renderer-hydration-script": {
const { rendererSpecificHydrationScripts } = result._metadata;
const { rendererName } = instruction;
if (!rendererSpecificHydrationScripts.has(rendererName)) {
rendererSpecificHydrationScripts.add(rendererName);
return instruction.render();
}
return "";
}
default: {
throw new Error(`Unknown chunk type: ${chunk.type}`);
}
}
} else if (chunk instanceof Response) {
return "";
} 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$1.decode(chunk);
} else {
return stringifyChunk(result, chunk);
}
}
function chunkToByteArray(result, chunk) {
if (ArrayBuffer.isView(chunk)) {
return chunk;
} else {
const stringified = stringifyChunk(result, chunk);
return encoder$1.encode(stringified.toString());
}
}
function isRenderInstance(obj) {
return !!obj && typeof obj === "object" && "render" in obj && typeof obj.render === "function";
}
async function renderChild(destination, child) {
if (isPromise(child)) {
child = await child;
}
if (child instanceof SlotString) {
destination.write(child);
} else if (isHTMLString(child)) {
destination.write(child);
} else if (Array.isArray(child)) {
const childRenders = child.map((c) => {
return renderToBufferDestination((bufferDestination) => {
return renderChild(bufferDestination, c);
});
});
for (const childRender of childRenders) {
if (!childRender) continue;
await childRender.renderToFinalDestination(destination);
}
} 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);
}
}
const astroComponentInstanceSym = Symbol.for("astro.componentInstance");
class AstroComponentInstance {
[astroComponentInstanceSym] = true;
result;
props;
slotValues;
factory;
returnValue;
constructor(result, props, slots, factory) {
this.result = result;
this.props = props;
this.factory = factory;
this.slotValues = {};
for (const name in slots) {
let didRender = false;
let value = slots[name](result);
this.slotValues[name] = () => {
if (!didRender) {
didRender = true;
return value;
}
return slots[name](result);
};
}
}
async init(result) {
if (this.returnValue !== void 0) return this.returnValue;
this.returnValue = this.factory(result, this.props, this.slotValues);
if (isPromise(this.returnValue)) {
this.returnValue.then((resolved) => {
this.returnValue = resolved;
}).catch(() => {
});
}
return this.returnValue;
}
async render(destination) {
const returnValue = await this.init(this.result);
if (isHeadAndContent(returnValue)) {
await returnValue.content.render(destination);
} else {
await renderChild(destination, returnValue);
}
}
}
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.add(instance);
}
return instance;
}
function isAstroComponentInstance(obj) {
return typeof obj === "object" && obj !== null && !!obj[astroComponentInstanceSym];
}
const DOCTYPE_EXP = /<!doctype html/i;
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;
if (isPage) {
await bufferHeadContent(result);
}
const destination = {
write(chunk) {
if (isPage && !renderedFirstPageChunk) {
renderedFirstPageChunk = true;
if (!result.partial && !DOCTYPE_EXP.test(String(chunk))) {
const doctype = result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n";
str += doctype;
}
}
if (chunk instanceof Response) return;
str += chunkToString(result, chunk);
}
};
await templateResult.render(destination);
return str;
}
async function renderToReadableStream(result, componentFactory, props, children, isPage = false, route) {
const templateResult = await callComponentAsTemplateResultOrResponse(
result,
componentFactory,
props,
children,
route
);
if (templateResult instanceof Response) return templateResult;
let renderedFirstPageChunk = false;
if (isPage) {
await bufferHeadContent(result);
}
return new ReadableStream({
start(controller) {
const destination = {
write(chunk) {
if (isPage && !renderedFirstPageChunk) {
renderedFirstPageChunk = true;
if (!result.partial && !DOCTYPE_EXP.test(String(chunk))) {
const doctype = result.compressHTML ? "<!DOCTYPE html>" : "<!DOCTYPE html>\n";
controller.enqueue(encoder$1.encode(doctype));
}
}
if (chunk instanceof Response) {
throw new AstroError({
...ResponseSentError
});
}
const bytes = chunkToByteArray(result, chunk);
controller.enqueue(bytes);
}
};
(async () => {
try {
await templateResult.render(destination);
controller.close();
} catch (e) {
if (AstroError.is(e) && !e.loc) {
e.setLocation({
file: route?.component
});
}
setTimeout(() => controller.error(e), 0);
}
})();
},
cancel() {
result.cancelled = true;
}
});
}
async function callComponentAsTemplateResultOrResponse(result, componentFactory, props, children, route) {
const factoryResult = await componentFactory(result, props, children);
if (factoryResult instanceof Response) {
return factoryResult;
} else if (isHeadAndContent(factoryResult)) {
if (!isRenderTemplateResult(factoryResult.content)) {
throw new AstroError({
...OnlyResponseCanBeReturned,
message: OnlyResponseCanBeReturned.message(
route?.route,
typeof factoryResult
),
location: {
file: route?.component
}
});
}
return factoryResult.content;
} else if (!isRenderTemplateResult(factoryResult)) {
throw new AstroError({
...OnlyResponseCanBeReturned,
message: OnlyResponseCanBeReturned.message(route?.route, typeof factoryResult),
location: {
file: route?.component
}
});
}
return factoryResult;
}
async function bufferHeadContent(result) {
const iterator = result._metadata.propagators.values();
while (true) {
const { value, done } = iterator.next();
if (done) {
break;
}
const returnValue = await value.init(result);
if (isHeadAndContent(returnValue)) {
result._metadata.extraHead.push(returnValue.head);
}
}
}
async function renderToAsyncIterable(result, componentFactory, props, children, isPage = false, route) {
const templateResult = await callComponentAsTemplateResultOrResponse(
result,
componentFactory,
props,
children,
route
);
if (templateResult instanceof Response) return templateResult;
let renderedFirstPageChunk = false;
if (isPage) {
await bufferHeadContent(result);
}
let error = null;
let next = null;
const buffer = [];
let renderingComplete = false;
const iterator = {
async next() {
if (result.cancelled) return { done: true, value: void 0 };
if (next !== null) {
await next.promise;
} else if (!renderingComplete && !buffer.length) {
next = promiseWithResolvers();
await next.promise;
}
if (!renderingComplete) {
next = promiseWithResolvers();
}
if (error) {
throw error;
}
let length = 0;
for (let i = 0, len = buffer.length; i < len; i++) {
length += buffer[i].length;
}
let mergedArray = new Uint8Array(length);
let offset = 0;
for (let i = 0, len = buffer.length; i < len; i++) {
const item = buffer[i];
mergedArray.set(item, offset);
offset += item.length;
}
buffer.length = 0;
const returnValue = {
// The iterator is done when rendering has finished
// and there are no more chunks to return.
done: length === 0 && renderingComplete,
value: mergedArray
};
return returnValue;
},
async return() {
result.cancelled = true;
return { done: true, value: void 0 };
}
};
const destination = {
write(chunk) {
if (isPage && !renderedFirstPageChunk) {
renderedFirstPageChunk = true;
if (!result.partial && !DOCTYPE_EXP.test(String(chunk))) {
const docty