Complete residential site build with Docker Compose & Gitea Actions deployment

node_modules/@astrojs/prism/dist/highlighter.d.ts

@@ -0,0 +1,4 @@
+export declare function runHighlighterWithAstro(lang: string | undefined, code: string): Promise<{
+    classLanguage: string;
+    html: string;
+}>;

node_modules/@astrojs/prism/dist/highlighter.js

@@ -0,0 +1,36 @@
+import Prism from "prismjs";
+import { loadLanguages } from "#prism-loadLanguages";
+import { addAstro } from "./plugin.js";
+const languageMap = /* @__PURE__ */ new Map([["ts", "typescript"]]);
+async function runHighlighterWithAstro(lang, code) {
+  if (!lang) {
+    lang = "plaintext";
+  }
+  let classLanguage = `language-${lang}`;
+  const ensureLoaded = async (language) => {
+    if (language && !Prism.languages[language]) {
+      await loadLanguages([language]);
+    }
+  };
+  if (languageMap.has(lang)) {
+    await ensureLoaded(languageMap.get(lang));
+  } else if (lang === "astro") {
+    await ensureLoaded("typescript");
+    addAstro(Prism);
+  } else {
+    await ensureLoaded("markup-templating");
+    await ensureLoaded(lang);
+  }
+  if (lang && !Prism.languages[lang]) {
+    console.warn(`Unable to load the language: ${lang}`);
+  }
+  const grammar = Prism.languages[lang];
+  let html = code;
+  if (grammar) {
+    html = Prism.highlight(code, grammar, lang);
+  }
+  return { classLanguage, html };
+}
+export {
+  runHighlighterWithAstro
+};

node_modules/@astrojs/prism/dist/index.d.ts

@@ -0,0 +1 @@
+export { default as Prism } from '../Prism.astro';

node_modules/@astrojs/prism/dist/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "../Prism.astro";
+export {
+  default2 as Prism
+};

node_modules/@astrojs/prism/dist/loadLanguages-default.d.ts

@@ -0,0 +1 @@
+export declare function loadLanguages(languages: string | string[]): Promise<void>;

node_modules/@astrojs/prism/dist/loadLanguages-default.js

@@ -0,0 +1,7 @@
+import prismLoadLanguages from "prismjs/components/index.js";
+async function loadLanguages(languages) {
+  return prismLoadLanguages(languages);
+}
+export {
+  loadLanguages
+};

node_modules/@astrojs/prism/dist/loadLanguages-workerd.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Loads the given languages and adds them to the current Prism instance.
+ *
+ * If no languages are provided, __all__ Prism languages will be loaded.
+ *
+ * @param {string|string[]} [languages]
+ * @returns {Promise<void>}
+ */
+export declare function loadLanguages(languages: string | string[]): Promise<void>;
+export declare namespace loadLanguages {
+    var silent: boolean;
+}

node_modules/@astrojs/prism/dist/loadLanguages-workerd.js

@@ -0,0 +1,56 @@
+import Prism from "prismjs";
+import components from "prismjs/components.js";
+import getLoader, {} from "prismjs/dependencies.js";
+import { bundledLanguages } from "virtual:astro-cloudflare:prism";
+const loadChainer = {
+  series: async (before, after) => {
+    await before;
+    await after();
+  },
+  parallel: async (values) => {
+    await Promise.all(values);
+  }
+};
+let prismRefCount = 0;
+const prismRefCounter = {
+  increment: () => {
+    if (prismRefCount === 0) {
+      globalThis.Prism = Prism;
+    }
+    prismRefCount += 1;
+  },
+  decrement: () => {
+    prismRefCount -= 1;
+    if (prismRefCount === 0) {
+      delete globalThis.Prism;
+    }
+  }
+};
+const loadedLanguages = /* @__PURE__ */ new Set();
+async function loadLanguages(languages) {
+  prismRefCounter.increment();
+  if (languages === void 0) {
+    languages = Object.keys(components.languages).filter((l) => l !== "meta");
+  } else if (!Array.isArray(languages)) {
+    languages = [languages];
+  }
+  const loaded = [...loadedLanguages, ...Object.keys(Prism.languages)];
+  await getLoader(components, languages, loaded).load(async (lang) => {
+    if (!(lang in components.languages)) {
+      if (!loadLanguages.silent) {
+        console.warn("Language does not exist: " + lang);
+      }
+      return;
+    }
+    delete Prism.languages[lang];
+    if (Object.hasOwn(bundledLanguages, lang)) {
+      await bundledLanguages[lang]();
+    }
+    loadedLanguages.add(lang);
+  }, loadChainer);
+  prismRefCounter.decrement();
+}
+loadLanguages.silent = false;
+export {
+  loadLanguages
+};

node_modules/@astrojs/prism/dist/plugin.d.ts

@@ -0,0 +1 @@
+export declare function addAstro(Prism: typeof import('prismjs')): void;

node_modules/@astrojs/prism/dist/plugin.js

@@ -0,0 +1,139 @@
+function addAstro(Prism) {
+  if (Prism.languages.astro) {
+    return;
+  }
+  let scriptLang;
+  if (Prism.languages.typescript) {
+    scriptLang = "typescript";
+  } else {
+    scriptLang = "javascript";
+    console.warn(
+      "Prism TypeScript language not loaded, Astro scripts will be treated as JavaScript."
+    );
+  }
+  let script = Prism.util.clone(Prism.languages[scriptLang]);
+  let space = /(?:\s|\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))\*\/)/.source;
+  let braces = /(?:\{(?:\{(?:\{[^{}]*\}|[^{}])*\}|[^{}])*\})/.source;
+  let spread = /(?:\{<S>*\.{3}(?:[^{}]|<BRACES>)*\})/.source;
+  function re(source, flags) {
+    source = source.replace(/<S>/g, function() {
+      return space;
+    }).replace(/<BRACES>/g, function() {
+      return braces;
+    }).replace(/<SPREAD>/g, function() {
+      return spread;
+    });
+    return RegExp(source, flags);
+  }
+  spread = re(spread).source;
+  Prism.languages.astro = Prism.languages.extend("markup", script);
+  Prism.languages.astro.tag.pattern = re(
+    /<\/?(?:[\w.:-]+(?:<S>+(?:[\w.:$-]+(?:=(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s{'"/>=]+|<BRACES>))?|<SPREAD>))*<S>*\/?)?>/.source
+  );
+  Prism.languages.astro.tag.inside["tag"].pattern = /^<\/?[^\s>/]*/;
+  Prism.languages.astro.tag.inside["attr-value"].pattern = /=(?!\{)(?:"(?:\\[\s\S]|[^\\"])*"|'(?:\\[\s\S]|[^\\'])*'|[^\s'">]+)/;
+  Prism.languages.astro.tag.inside["tag"].inside["class-name"] = /^[A-Z]\w*(?:\.[A-Z]\w*)*$/;
+  Prism.languages.astro.tag.inside["comment"] = script["comment"];
+  Prism.languages.insertBefore(
+    "inside",
+    "attr-name",
+    {
+      spread: {
+        pattern: re(/<SPREAD>/.source),
+        inside: Prism.languages.astro
+      }
+    },
+    Prism.languages.astro.tag
+  );
+  Prism.languages.insertBefore(
+    "inside",
+    "special-attr",
+    {
+      script: {
+        // Allow for two levels of nesting
+        pattern: re(/=<BRACES>/.source),
+        inside: {
+          "script-punctuation": {
+            pattern: /^=(?=\{)/,
+            alias: "punctuation"
+          },
+          rest: Prism.languages.astro
+        },
+        alias: `language-${scriptLang}`
+      }
+    },
+    Prism.languages.astro.tag
+  );
+  let stringifyToken = function(token) {
+    if (!token) {
+      return "";
+    }
+    if (typeof token === "string") {
+      return token;
+    }
+    if (typeof token.content === "string") {
+      return token.content;
+    }
+    return token.content.map(stringifyToken).join("");
+  };
+  let walkTokens = function(tokens) {
+    let openedTags = [];
+    for (let i = 0; i < tokens.length; i++) {
+      let token = tokens[i];
+      if (token.type === "style") {
+        return;
+      }
+      let notTagNorBrace = false;
+      if (typeof token !== "string") {
+        if (token.type === "tag" && token.content[0] && token.content[0].type === "tag") {
+          if (token.content[0].content[0].content === "</") {
+            if (openedTags.length > 0 && openedTags[openedTags.length - 1].tagName === stringifyToken(token.content[0].content[1])) {
+              openedTags.pop();
+            }
+          } else {
+            if (token.content[token.content.length - 1].content === "/>") {
+            } else {
+              openedTags.push({
+                tagName: stringifyToken(token.content[0].content[1]),
+                openedBraces: 0
+              });
+            }
+          }
+        } else if (openedTags.length > 0 && token.type === "punctuation" && token.content === "{") {
+          openedTags[openedTags.length - 1].openedBraces++;
+        } else if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces > 0 && token.type === "punctuation" && token.content === "}") {
+          openedTags[openedTags.length - 1].openedBraces--;
+        } else {
+          notTagNorBrace = true;
+        }
+      }
+      if (notTagNorBrace || typeof token === "string") {
+        if (openedTags.length > 0 && openedTags[openedTags.length - 1].openedBraces === 0) {
+          let plainText = stringifyToken(token);
+          if (i < tokens.length - 1 && (typeof tokens[i + 1] === "string" || tokens[i + 1].type === "plain-text")) {
+            plainText += stringifyToken(tokens[i + 1]);
+            tokens.splice(i + 1, 1);
+          }
+          if (i > 0 && (typeof tokens[i - 1] === "string" || tokens[i - 1].type === "plain-text")) {
+            plainText = stringifyToken(tokens[i - 1]) + plainText;
+            tokens.splice(i - 1, 1);
+            i--;
+          }
+          tokens[i] = new Prism.Token("plain-text", plainText, void 0, plainText);
+        }
+      }
+      if (token.content && typeof token.content !== "string") {
+        walkTokens(token.content);
+      }
+    }
+  };
+  Prism.hooks.add("after-tokenize", function(env) {
+    if (env.language !== "astro") {
+      return;
+    }
+    walkTokens(env.tokens);
+  });
+}
+export {
+  addAstro
+};