@d10f/asciidoc-astro-loader 0.0.1 → 0.0.2

package/dist/{chunk-HAZIHU2Y.js → chunk-BRMWIQA2.js}

@@ -5,16 +5,12 @@ import {
 } from "./chunk-DDIUST2Z.js";
 
 // src/lib/asciidoc/converters/sourceCodeConverter.ts
-import {
-  transformerNotationDiff,
-  transformerNotationFocus,
-  transformerNotationHighlight
-} from "@shikijs/transformers";
 import { resolve } from "path";
-var sourceCodeConverter = ({ nodeContext, transformers, template }) => {
+var sourceCodeConverter = ({ transformers, template }) => {
   return (options, highlighter) => {
     return {
-      nodeContext: nodeContext ?? "listing",
+      nodeContext: "listing",
+      nodeStyle: "source",
       convert(node, templateEngine) {
         const input = node.getSourceLines().join("\n");
         const lang = node.getAttribute("language");
@@ -23,9 +19,6 @@ var sourceCodeConverter = ({ nodeContext, transformers, template }) => {
           lang,
           transformers: [
             ...transformers ?? [],
-            transformerNotationDiff(),
-            transformerNotationHighlight(),
-            transformerNotationFocus(),
             transformAsciidocCallout({ node }),
             transformConsoleCodeBlock()
           ]

package/dist/{index-Cf7MF6tZ.d.cts → index-BNxO58s3.d.cts}

@@ -1,6 +1,6 @@
-import { HighlighterCore, CodeToHastOptions, CodeOptionsMultipleThemes, ThemeRegistrationAny, StringLiteralUnion, BundledTheme } from 'shiki';
-import { AbstractNode } from 'asciidoctor';
-import { z } from 'zod';
+import { HighlighterCore, CodeToHastOptions, CodeOptionsMultipleThemes, ThemeRegistrationAny, StringLiteralUnion, BundledTheme, ShikiTransformer } from 'shiki';
+import { AbstractNode, AbstractBlock } from 'asciidoctor';
+import { z } from 'astro/zod';
 
 type RequiredOptions = z.output<typeof loaderOptionsSchema>;
 type DocumentOptions = RequiredOptions['document'];
@@ -8,33 +8,88 @@ type PreambleOptions = RequiredOptions['preamble'];
 declare const loaderOptionsSchema: z.ZodObject<{
     base: z.ZodString;
     document: z.ZodDefault<z.ZodObject<{
-        mode: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
-        template: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<string, string>>;
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
+        template: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
         recursive: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$loose>>;
-    syntaxHighlighting: z.ZodDefault<z.ZodPipe<z.ZodObject<{
-        theme: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
+        template: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
+        template: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    syntaxHighlighting: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        theme: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodObject<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, "strip", z.ZodString, z.objectOutputType<{
             light: z.ZodString;
             dark: z.ZodString;
-        }, z.core.$catchall<z.ZodString>>]>, z.ZodTransform<{
+        }, z.ZodString, "strip">, z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip">>]>, {
             light: string;
             dark: string;
         } & {
             [other: string]: string;
-        }, string | {
-            [x: string]: string;
-            light: string;
-            dark: string;
-        }>>>;
+        }, string | z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip">>>;
         defaultColor: z.ZodDefault<z.ZodString>;
         cssVariablePrefix: z.ZodDefault<z.ZodString>;
-        mergeWhitespaces: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"never">]>>;
-        tabindex: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodLiteral<false>]>>;
-    }, z.core.$strip>, z.ZodTransform<{
+        mergeWhitespaces: z.ZodDefault<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"never">]>>;
+        tabindex: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodLiteral<false>]>>;
+        transformers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            enforce: z.ZodUnion<[z.ZodLiteral<"pre">, z.ZodLiteral<"post">]>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            enforce: "pre" | "post";
+        }, {
+            name: string;
+            enforce: "pre" | "post";
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        theme: {
+            light: string;
+            dark: string;
+        } & {
+            [other: string]: string;
+        };
         defaultColor: string;
         cssVariablePrefix: string;
         mergeWhitespaces: boolean | "never";
         tabindex: string | number | false;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+    }, {
+        theme?: string | z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip"> | undefined;
+        defaultColor?: string | undefined;
+        cssVariablePrefix?: string | undefined;
+        mergeWhitespaces?: boolean | "never" | undefined;
+        tabindex?: string | number | false | undefined;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+    }>, {
+        defaultColor: string;
+        cssVariablePrefix: string;
+        mergeWhitespaces: boolean | "never";
+        tabindex: string | number | false;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
         themes: {
             light: string;
             dark: string;
@@ -42,23 +97,89 @@ declare const loaderOptionsSchema: z.ZodObject<{
             [other: string]: string;
         };
     }, {
-        theme: {
+        theme?: string | z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip"> | undefined;
+        defaultColor?: string | undefined;
+        cssVariablePrefix?: string | undefined;
+        mergeWhitespaces?: boolean | "never" | undefined;
+        tabindex?: string | number | false | undefined;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+    }>>;
+    preamble: z.ZodDefault<z.ZodObject<{
+        tableOfContents: z.ZodDefault<z.ZodBoolean>;
+        maxLevel: z.ZodDefault<z.ZodNumber>;
+        position: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"before">, z.ZodLiteral<"after">]>>;
+    }, "strip", z.ZodTypeAny, {
+        tableOfContents: boolean;
+        maxLevel: number;
+        position: "before" | "after";
+    }, {
+        tableOfContents?: boolean | undefined;
+        maxLevel?: number | undefined;
+        position?: "before" | "after" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    base: string;
+    document: {
+        mode: "safe" | "unsafe";
+        template: string;
+        recursive: boolean;
+    } & {
+        [k: string]: unknown;
+    };
+    syntaxHighlighting: {
+        defaultColor: string;
+        cssVariablePrefix: string;
+        mergeWhitespaces: boolean | "never";
+        tabindex: string | number | false;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+        themes: {
             light: string;
             dark: string;
         } & {
             [other: string]: string;
         };
-        defaultColor: string;
-        cssVariablePrefix: string;
-        mergeWhitespaces: boolean | "never";
-        tabindex: string | number | false;
-    }>>>;
-    preamble: z.ZodDefault<z.ZodObject<{
-        tableOfContents: z.ZodDefault<z.ZodBoolean>;
-        maxLevel: z.ZodDefault<z.ZodNumber>;
-        position: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"before">, z.ZodLiteral<"after">]>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    };
+    preamble: {
+        tableOfContents: boolean;
+        maxLevel: number;
+        position: "before" | "after";
+    };
+}, {
+    base: string;
+    document?: z.objectInputType<{
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
+        template: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    syntaxHighlighting?: {
+        theme?: string | z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip"> | undefined;
+        defaultColor?: string | undefined;
+        cssVariablePrefix?: string | undefined;
+        mergeWhitespaces?: boolean | "never" | undefined;
+        tabindex?: string | number | false | undefined;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+    } | undefined;
+    preamble?: {
+        tableOfContents?: boolean | undefined;
+        maxLevel?: number | undefined;
+        position?: "before" | "after" | undefined;
+    } | undefined;
+}>;
 
 declare abstract class AbstractEngine {
     private _name;
@@ -141,7 +262,7 @@ declare class TemplateEngineRegistry {
      * engine itself with _getEngineByName_ or _getEngineByExtension_
      * and use one of its render methods directly.
      */
-    convert(node: AbstractNode, options?: Record<string, unknown>): string | undefined;
+    convert(node: AbstractBlock, options?: Record<string, unknown>): string | undefined;
     /**
      * Scans the templates directory and creates an index of all templates
      * based on supported block names and extensions.
@@ -279,6 +400,12 @@ type AsciidocLoader = {
             dark: BundledTheme;
             [customTheme: string]: BundledTheme;
         };
+        /**
+         * A list of transformers to apply for source code blocks.
+         *
+         * @default [ transformerNotationDiff, transformerNotationHighlight, transformerNotationFocus ]
+         */
+        transformers: ShikiTransformer[];
     }>;
 };
 /**
@@ -305,7 +432,7 @@ interface TemplateModule {
  * to the template rendering process.
  */
 interface AsciidocTemplate {
-    renderNode(node: AbstractNode, options?: Record<string, unknown>): string;
+    renderNode(node: AbstractBlock, options?: Record<string, unknown>): string;
 }
 /**
  * Designates that the template will receive a file location that points

package/dist/{index-Cf7MF6tZ.d.ts → index-BNxO58s3.d.ts}

@@ -1,6 +1,6 @@
-import { HighlighterCore, CodeToHastOptions, CodeOptionsMultipleThemes, ThemeRegistrationAny, StringLiteralUnion, BundledTheme } from 'shiki';
-import { AbstractNode } from 'asciidoctor';
-import { z } from 'zod';
+import { HighlighterCore, CodeToHastOptions, CodeOptionsMultipleThemes, ThemeRegistrationAny, StringLiteralUnion, BundledTheme, ShikiTransformer } from 'shiki';
+import { AbstractNode, AbstractBlock } from 'asciidoctor';
+import { z } from 'astro/zod';
 
 type RequiredOptions = z.output<typeof loaderOptionsSchema>;
 type DocumentOptions = RequiredOptions['document'];
@@ -8,33 +8,88 @@ type PreambleOptions = RequiredOptions['preamble'];
 declare const loaderOptionsSchema: z.ZodObject<{
     base: z.ZodString;
     document: z.ZodDefault<z.ZodObject<{
-        mode: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
-        template: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<string, string>>;
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
+        template: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
         recursive: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$loose>>;
-    syntaxHighlighting: z.ZodDefault<z.ZodPipe<z.ZodObject<{
-        theme: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
+        template: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
+        template: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    syntaxHighlighting: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        theme: z.ZodDefault<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodObject<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, "strip", z.ZodString, z.objectOutputType<{
             light: z.ZodString;
             dark: z.ZodString;
-        }, z.core.$catchall<z.ZodString>>]>, z.ZodTransform<{
+        }, z.ZodString, "strip">, z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip">>]>, {
             light: string;
             dark: string;
         } & {
             [other: string]: string;
-        }, string | {
-            [x: string]: string;
-            light: string;
-            dark: string;
-        }>>>;
+        }, string | z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip">>>;
         defaultColor: z.ZodDefault<z.ZodString>;
         cssVariablePrefix: z.ZodDefault<z.ZodString>;
-        mergeWhitespaces: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"never">]>>;
-        tabindex: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodLiteral<false>]>>;
-    }, z.core.$strip>, z.ZodTransform<{
+        mergeWhitespaces: z.ZodDefault<z.ZodUnion<[z.ZodBoolean, z.ZodLiteral<"never">]>>;
+        tabindex: z.ZodDefault<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodLiteral<false>]>>;
+        transformers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            enforce: z.ZodUnion<[z.ZodLiteral<"pre">, z.ZodLiteral<"post">]>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            enforce: "pre" | "post";
+        }, {
+            name: string;
+            enforce: "pre" | "post";
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        theme: {
+            light: string;
+            dark: string;
+        } & {
+            [other: string]: string;
+        };
         defaultColor: string;
         cssVariablePrefix: string;
         mergeWhitespaces: boolean | "never";
         tabindex: string | number | false;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+    }, {
+        theme?: string | z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip"> | undefined;
+        defaultColor?: string | undefined;
+        cssVariablePrefix?: string | undefined;
+        mergeWhitespaces?: boolean | "never" | undefined;
+        tabindex?: string | number | false | undefined;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+    }>, {
+        defaultColor: string;
+        cssVariablePrefix: string;
+        mergeWhitespaces: boolean | "never";
+        tabindex: string | number | false;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
         themes: {
             light: string;
             dark: string;
@@ -42,23 +97,89 @@ declare const loaderOptionsSchema: z.ZodObject<{
             [other: string]: string;
         };
     }, {
-        theme: {
+        theme?: string | z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip"> | undefined;
+        defaultColor?: string | undefined;
+        cssVariablePrefix?: string | undefined;
+        mergeWhitespaces?: boolean | "never" | undefined;
+        tabindex?: string | number | false | undefined;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+    }>>;
+    preamble: z.ZodDefault<z.ZodObject<{
+        tableOfContents: z.ZodDefault<z.ZodBoolean>;
+        maxLevel: z.ZodDefault<z.ZodNumber>;
+        position: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"before">, z.ZodLiteral<"after">]>>;
+    }, "strip", z.ZodTypeAny, {
+        tableOfContents: boolean;
+        maxLevel: number;
+        position: "before" | "after";
+    }, {
+        tableOfContents?: boolean | undefined;
+        maxLevel?: number | undefined;
+        position?: "before" | "after" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    base: string;
+    document: {
+        mode: "safe" | "unsafe";
+        template: string;
+        recursive: boolean;
+    } & {
+        [k: string]: unknown;
+    };
+    syntaxHighlighting: {
+        defaultColor: string;
+        cssVariablePrefix: string;
+        mergeWhitespaces: boolean | "never";
+        tabindex: string | number | false;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+        themes: {
             light: string;
             dark: string;
         } & {
             [other: string]: string;
         };
-        defaultColor: string;
-        cssVariablePrefix: string;
-        mergeWhitespaces: boolean | "never";
-        tabindex: string | number | false;
-    }>>>;
-    preamble: z.ZodDefault<z.ZodObject<{
-        tableOfContents: z.ZodDefault<z.ZodBoolean>;
-        maxLevel: z.ZodDefault<z.ZodNumber>;
-        position: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"before">, z.ZodLiteral<"after">]>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+    };
+    preamble: {
+        tableOfContents: boolean;
+        maxLevel: number;
+        position: "before" | "after";
+    };
+}, {
+    base: string;
+    document?: z.objectInputType<{
+        mode: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"safe">, z.ZodLiteral<"unsafe">]>>;
+        template: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
+        recursive: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    syntaxHighlighting?: {
+        theme?: string | z.objectInputType<{
+            light: z.ZodString;
+            dark: z.ZodString;
+        }, z.ZodString, "strip"> | undefined;
+        defaultColor?: string | undefined;
+        cssVariablePrefix?: string | undefined;
+        mergeWhitespaces?: boolean | "never" | undefined;
+        tabindex?: string | number | false | undefined;
+        transformers?: {
+            name: string;
+            enforce: "pre" | "post";
+        }[] | undefined;
+    } | undefined;
+    preamble?: {
+        tableOfContents?: boolean | undefined;
+        maxLevel?: number | undefined;
+        position?: "before" | "after" | undefined;
+    } | undefined;
+}>;
 
 declare abstract class AbstractEngine {
     private _name;
@@ -141,7 +262,7 @@ declare class TemplateEngineRegistry {
      * engine itself with _getEngineByName_ or _getEngineByExtension_
      * and use one of its render methods directly.
      */
-    convert(node: AbstractNode, options?: Record<string, unknown>): string | undefined;
+    convert(node: AbstractBlock, options?: Record<string, unknown>): string | undefined;
     /**
      * Scans the templates directory and creates an index of all templates
      * based on supported block names and extensions.
@@ -279,6 +400,12 @@ type AsciidocLoader = {
             dark: BundledTheme;
             [customTheme: string]: BundledTheme;
         };
+        /**
+         * A list of transformers to apply for source code blocks.
+         *
+         * @default [ transformerNotationDiff, transformerNotationHighlight, transformerNotationFocus ]
+         */
+        transformers: ShikiTransformer[];
     }>;
 };
 /**
@@ -305,7 +432,7 @@ interface TemplateModule {
  * to the template rendering process.
  */
 interface AsciidocTemplate {
-    renderNode(node: AbstractNode, options?: Record<string, unknown>): string;
+    renderNode(node: AbstractBlock, options?: Record<string, unknown>): string;
 }
 /**
  * Designates that the template will receive a file location that points

package/dist/index.cjs

@@ -288,23 +288,23 @@ var AsciidocDocument = class {
 };
 
 // src/schemas/index.ts
-var import_zod3 = require("zod");
+var import_zod3 = require("astro/zod");
 
 // src/schemas/document.ts
 var import_node_path = require("path");
-var import_zod = require("zod");
-var documentOptionsSchema = import_zod.z.looseObject({
+var import_zod = require("astro/zod");
+var documentOptionsSchema = import_zod.z.object({
   mode: import_zod.z.union([import_zod.z.literal("safe"), import_zod.z.literal("unsafe")]).default("safe"),
-  template: import_zod.z.string().default("").transform((val) => (0, import_node_path.resolve)(process.cwd(), val)),
+  template: import_zod.z.string().default("").transform((val) => val ? (0, import_node_path.resolve)(process.cwd(), val) : ""),
   recursive: import_zod.z.boolean().default(false)
-}).default({
+}).passthrough().default({
   mode: "safe",
   template: "",
   recursive: false
 });
 
 // src/schemas/shiki.ts
-var import_zod2 = require("zod");
+var import_zod2 = require("astro/zod");
 var shikiOptionsSchema = import_zod2.z.object({
   theme: import_zod2.z.union([
     import_zod2.z.string(),
@@ -319,7 +319,13 @@ var shikiOptionsSchema = import_zod2.z.object({
   defaultColor: import_zod2.z.string().default("light-dark()"),
   cssVariablePrefix: import_zod2.z.string().default("--shiki-"),
   mergeWhitespaces: import_zod2.z.union([import_zod2.z.boolean(), import_zod2.z.literal("never")]).default(true),
-  tabindex: import_zod2.z.union([import_zod2.z.number(), import_zod2.z.string(), import_zod2.z.literal(false)]).default(false)
+  tabindex: import_zod2.z.union([import_zod2.z.number(), import_zod2.z.string(), import_zod2.z.literal(false)]).default(false),
+  transformers: import_zod2.z.array(
+    import_zod2.z.object({
+      name: import_zod2.z.string(),
+      enforce: import_zod2.z.union([import_zod2.z.literal("pre"), import_zod2.z.literal("post")])
+    })
+  ).optional()
 }).transform(({ theme, ...rest }) => ({
   themes: theme,
   ...rest
@@ -331,7 +337,8 @@ var shikiOptionsSchema = import_zod2.z.object({
   theme: {
     light: "catppuccin-latte",
     dark: "catppuccin-macchiato"
-  }
+  },
+  transformers: void 0
 });
 function transformThemeProp(value) {
   return typeof value === "string" ? { light: value, dark: value } : value;
@@ -376,7 +383,6 @@ async function createHighlighter(documents, themes) {
 }
 
 // src/lib/asciidoc/converters/sourceCodeConverter.ts
-var import_transformers = require("@shikijs/transformers");
 var import_node_path2 = require("path");
 
 // src/lib/shiki/transformers/transformAsciidocCallout.ts
@@ -470,10 +476,11 @@ function transformConsoleCodeBlock(options = {
 }
 
 // src/lib/asciidoc/converters/sourceCodeConverter.ts
-var sourceCodeConverter = ({ nodeContext, transformers, template }) => {
+var sourceCodeConverter = ({ transformers, template }) => {
   return (options, highlighter) => {
     return {
-      nodeContext: nodeContext ?? "listing",
+      nodeContext: "listing",
+      nodeStyle: "source",
       convert(node, templateEngine) {
         const input = node.getSourceLines().join("\n");
         const lang = node.getAttribute("language");
@@ -482,9 +489,6 @@ var sourceCodeConverter = ({ nodeContext, transformers, template }) => {
           lang,
           transformers: [
             ...transformers ?? [],
-            (0, import_transformers.transformerNotationDiff)(),
-            (0, import_transformers.transformerNotationHighlight)(),
-            (0, import_transformers.transformerNotationFocus)(),
             transformAsciidocCallout({ node }),
             transformConsoleCodeBlock()
           ]
@@ -643,9 +647,7 @@ var NunjucksEngine = class extends AbstractEngine {
 function asciidocLoader(options) {
   const parsedOpts = loaderOptionsSchema.parse(options);
   if (parsedOpts.document.converters === void 0) {
-    parsedOpts.document.converters = [
-      sourceCodeConverter({ nodeContext: "listing" })
-    ];
+    parsedOpts.document.converters = [];
   }
   if (parsedOpts.document.templateEngines === void 0) {
     parsedOpts.document.templateEngines = [
@@ -653,9 +655,12 @@ function asciidocLoader(options) {
       new NunjucksEngine()
     ];
   }
+  let highlighter;
+  let templateEngine;
   return {
     name: "asciidoc-loader",
-    async load({ config, parseData, store, logger }) {
+    async load(loaderContext) {
+      const { config, logger, watcher } = loaderContext;
       const root = config.root.pathname;
       const base = parsedOpts.base.startsWith(".") ? (0, import_node_fs4.realpathSync)(options.base) : root + options.base;
       const docs = (0, import_node_fs4.readdirSync)(base, "utf8").filter((file) => file.match(/(?:\.a(?:scii)?doc)$/)).map((filename) => new AsciidocDocument(`${base}/${filename}`));
@@ -663,7 +668,6 @@ function asciidocLoader(options) {
         logger.warn("No documents found for this collection.");
         return;
       }
-      let templateEngine = void 0;
       if (parsedOpts.document.template) {
         templateEngine = new TemplateEngineRegistry(
           parsedOpts.document.templateEngines,
@@ -674,34 +678,82 @@ function asciidocLoader(options) {
         );
         await templateEngine.loadEngines();
       }
-      const highlighter = await createHighlighter(
-        docs,
-        parsedOpts.syntaxHighlighting.themes
-      );
+      if (!highlighter) {
+        highlighter = await createHighlighter(
+          docs,
+          parsedOpts.syntaxHighlighting.themes
+        );
+      }
       const converters = parsedOpts.document.converters.map(
         (converter) => converter(parsedOpts, highlighter)
       );
-      docs.forEach(async (doc) => {
-        const data = await parseData({
-          id: doc.slug,
-          data: {
-            title: doc.title,
-            createdAt: new Date(doc.createdAt),
-            description: doc.preamble
-          }
-        });
-        store.set({
-          id: doc.slug,
-          data,
-          rendered: {
-            html: doc.convert(converters, templateEngine)
+      const hasSourceCodeConverter = converters.find(
+        (converter) => converter.nodeContext === "listing" && converter?.nodeStyle === "source"
+      );
+      if (!hasSourceCodeConverter) {
+        converters.push(
+          sourceCodeConverter({
+            transformers: parsedOpts.syntaxHighlighting.transformers
+          })(parsedOpts, highlighter)
+        );
+      }
+      await Promise.all(
+        docs.map(
+          (doc) => syncDocument(
+            doc,
+            converters,
+            templateEngine,
+            loaderContext
+          )
+        )
+      );
+      if (watcher) {
+        let handle2 = function() {
+          logger.info("Shutting down highlighter instance");
+          highlighter.dispose();
+          process.exit(0);
+        };
+        var handle = handle2;
+        const watchedFileRegExp = new RegExp(
+          `^${base}.*.(a(?:scii)?doc)$`
+        );
+        console.log(this.name);
+        watcher.on("change", async (changedPath) => {
+          if (changedPath.match(watchedFileRegExp)) {
+            const newDoc = new AsciidocDocument(changedPath);
+            await syncDocument(
+              newDoc,
+              converters,
+              templateEngine,
+              loaderContext
+            );
           }
         });
-      });
-      (0, import_node_process.nextTick)(highlighter.dispose);
+        process.on("SIGINT", handle2);
+        process.on("SIGTERM", handle2);
+      } else {
+        (0, import_node_process.nextTick)(highlighter.dispose);
+      }
     }
   };
 }
+async function syncDocument(doc, converters, templateEngine, { parseData, store }) {
+  const data = await parseData({
+    id: doc.slug,
+    data: {
+      title: doc.title,
+      createdAt: new Date(doc.createdAt),
+      description: doc.preamble
+    }
+  });
+  store.set({
+    id: doc.slug,
+    data,
+    rendered: {
+      html: doc.convert(converters, templateEngine)
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   asciidocLoader

package/dist/index.d.cts

@@ -1,13 +1,13 @@
 import { LoaderContext } from 'astro/loaders';
-import { A as AsciidocLoader } from './index-Cf7MF6tZ.cjs';
-export { a as AsciidocTemplate, C as CustomConverterFactoryFn, F as FilesystemTemplate, N as NodeContext, R as RawTemplate } from './index-Cf7MF6tZ.cjs';
+import { A as AsciidocLoader } from './index-BNxO58s3.cjs';
+export { a as AsciidocTemplate, C as CustomConverterFactoryFn, F as FilesystemTemplate, N as NodeContext, R as RawTemplate } from './index-BNxO58s3.cjs';
 import 'shiki';
 import 'asciidoctor';
-import 'zod';
+import 'astro/zod';
 
 declare function asciidocLoader(options: AsciidocLoader): {
     name: string;
-    load({ config, parseData, store, logger }: LoaderContext): Promise<void>;
+    load(loaderContext: LoaderContext): Promise<void>;
 };
 
 export { asciidocLoader };

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import { LoaderContext } from 'astro/loaders';
-import { A as AsciidocLoader } from './index-Cf7MF6tZ.js';
-export { a as AsciidocTemplate, C as CustomConverterFactoryFn, F as FilesystemTemplate, N as NodeContext, R as RawTemplate } from './index-Cf7MF6tZ.js';
+import { A as AsciidocLoader } from './index-BNxO58s3.js';
+export { a as AsciidocTemplate, C as CustomConverterFactoryFn, F as FilesystemTemplate, N as NodeContext, R as RawTemplate } from './index-BNxO58s3.js';
 import 'shiki';
 import 'asciidoctor';
-import 'zod';
+import 'astro/zod';
 
 declare function asciidocLoader(options: AsciidocLoader): {
     name: string;
-    load({ config, parseData, store, logger }: LoaderContext): Promise<void>;
+    load(loaderContext: LoaderContext): Promise<void>;
 };
 
 export { asciidocLoader };

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   sourceCodeConverter
-} from "./chunk-HAZIHU2Y.js";
+} from "./chunk-BRMWIQA2.js";
 import {
   slugify,
   splitFilenameComponents
@@ -247,23 +247,23 @@ var AsciidocDocument = class {
 };
 
 // src/schemas/index.ts
-import { z as z3 } from "zod";
+import { z as z3 } from "astro/zod";
 
 // src/schemas/document.ts
 import { resolve } from "path";
-import { z } from "zod";
-var documentOptionsSchema = z.looseObject({
+import { z } from "astro/zod";
+var documentOptionsSchema = z.object({
   mode: z.union([z.literal("safe"), z.literal("unsafe")]).default("safe"),
-  template: z.string().default("").transform((val) => resolve(process.cwd(), val)),
+  template: z.string().default("").transform((val) => val ? resolve(process.cwd(), val) : ""),
   recursive: z.boolean().default(false)
-}).default({
+}).passthrough().default({
   mode: "safe",
   template: "",
   recursive: false
 });
 
 // src/schemas/shiki.ts
-import { z as z2 } from "zod";
+import { z as z2 } from "astro/zod";
 var shikiOptionsSchema = z2.object({
   theme: z2.union([
     z2.string(),
@@ -278,7 +278,13 @@ var shikiOptionsSchema = z2.object({
   defaultColor: z2.string().default("light-dark()"),
   cssVariablePrefix: z2.string().default("--shiki-"),
   mergeWhitespaces: z2.union([z2.boolean(), z2.literal("never")]).default(true),
-  tabindex: z2.union([z2.number(), z2.string(), z2.literal(false)]).default(false)
+  tabindex: z2.union([z2.number(), z2.string(), z2.literal(false)]).default(false),
+  transformers: z2.array(
+    z2.object({
+      name: z2.string(),
+      enforce: z2.union([z2.literal("pre"), z2.literal("post")])
+    })
+  ).optional()
 }).transform(({ theme, ...rest }) => ({
   themes: theme,
   ...rest
@@ -290,7 +296,8 @@ var shikiOptionsSchema = z2.object({
   theme: {
     light: "catppuccin-latte",
     dark: "catppuccin-macchiato"
-  }
+  },
+  transformers: void 0
 });
 function transformThemeProp(value) {
   return typeof value === "string" ? { light: value, dark: value } : value;
@@ -338,9 +345,7 @@ async function createHighlighter(documents, themes) {
 function asciidocLoader(options) {
   const parsedOpts = loaderOptionsSchema.parse(options);
   if (parsedOpts.document.converters === void 0) {
-    parsedOpts.document.converters = [
-      sourceCodeConverter({ nodeContext: "listing" })
-    ];
+    parsedOpts.document.converters = [];
   }
   if (parsedOpts.document.templateEngines === void 0) {
     parsedOpts.document.templateEngines = [
@@ -348,9 +353,12 @@ function asciidocLoader(options) {
       new NunjucksEngine()
     ];
   }
+  let highlighter;
+  let templateEngine;
   return {
     name: "asciidoc-loader",
-    async load({ config, parseData, store, logger }) {
+    async load(loaderContext) {
+      const { config, logger, watcher } = loaderContext;
       const root = config.root.pathname;
       const base = parsedOpts.base.startsWith(".") ? realpathSync(options.base) : root + options.base;
       const docs = readdirSync2(base, "utf8").filter((file) => file.match(/(?:\.a(?:scii)?doc)$/)).map((filename) => new AsciidocDocument(`${base}/${filename}`));
@@ -358,7 +366,6 @@ function asciidocLoader(options) {
         logger.warn("No documents found for this collection.");
         return;
       }
-      let templateEngine = void 0;
       if (parsedOpts.document.template) {
         templateEngine = new TemplateEngineRegistry(
           parsedOpts.document.templateEngines,
@@ -369,34 +376,82 @@ function asciidocLoader(options) {
         );
         await templateEngine.loadEngines();
       }
-      const highlighter = await createHighlighter(
-        docs,
-        parsedOpts.syntaxHighlighting.themes
-      );
+      if (!highlighter) {
+        highlighter = await createHighlighter(
+          docs,
+          parsedOpts.syntaxHighlighting.themes
+        );
+      }
       const converters = parsedOpts.document.converters.map(
         (converter) => converter(parsedOpts, highlighter)
       );
-      docs.forEach(async (doc) => {
-        const data = await parseData({
-          id: doc.slug,
-          data: {
-            title: doc.title,
-            createdAt: new Date(doc.createdAt),
-            description: doc.preamble
-          }
-        });
-        store.set({
-          id: doc.slug,
-          data,
-          rendered: {
-            html: doc.convert(converters, templateEngine)
+      const hasSourceCodeConverter = converters.find(
+        (converter) => converter.nodeContext === "listing" && converter?.nodeStyle === "source"
+      );
+      if (!hasSourceCodeConverter) {
+        converters.push(
+          sourceCodeConverter({
+            transformers: parsedOpts.syntaxHighlighting.transformers
+          })(parsedOpts, highlighter)
+        );
+      }
+      await Promise.all(
+        docs.map(
+          (doc) => syncDocument(
+            doc,
+            converters,
+            templateEngine,
+            loaderContext
+          )
+        )
+      );
+      if (watcher) {
+        let handle2 = function() {
+          logger.info("Shutting down highlighter instance");
+          highlighter.dispose();
+          process.exit(0);
+        };
+        var handle = handle2;
+        const watchedFileRegExp = new RegExp(
+          `^${base}.*.(a(?:scii)?doc)$`
+        );
+        console.log(this.name);
+        watcher.on("change", async (changedPath) => {
+          if (changedPath.match(watchedFileRegExp)) {
+            const newDoc = new AsciidocDocument(changedPath);
+            await syncDocument(
+              newDoc,
+              converters,
+              templateEngine,
+              loaderContext
+            );
           }
         });
-      });
-      nextTick(highlighter.dispose);
+        process.on("SIGINT", handle2);
+        process.on("SIGTERM", handle2);
+      } else {
+        nextTick(highlighter.dispose);
+      }
     }
   };
 }
+async function syncDocument(doc, converters, templateEngine, { parseData, store }) {
+  const data = await parseData({
+    id: doc.slug,
+    data: {
+      title: doc.title,
+      createdAt: new Date(doc.createdAt),
+      description: doc.preamble
+    }
+  });
+  store.set({
+    id: doc.slug,
+    data,
+    rendered: {
+      html: doc.convert(converters, templateEngine)
+    }
+  });
+}
 export {
   asciidocLoader
 };

package/dist/lib/asciidoc/converters/index.cjs

@@ -25,7 +25,6 @@ __export(converters_exports, {
 module.exports = __toCommonJS(converters_exports);
 
 // src/lib/asciidoc/converters/sourceCodeConverter.ts
-var import_transformers = require("@shikijs/transformers");
 var import_node_path = require("path");
 
 // src/lib/utils.ts
@@ -133,10 +132,11 @@ function transformConsoleCodeBlock(options = {
 }
 
 // src/lib/asciidoc/converters/sourceCodeConverter.ts
-var sourceCodeConverter = ({ nodeContext, transformers, template }) => {
+var sourceCodeConverter = ({ transformers, template }) => {
   return (options, highlighter) => {
     return {
-      nodeContext: nodeContext ?? "listing",
+      nodeContext: "listing",
+      nodeStyle: "source",
       convert(node, templateEngine) {
         const input = node.getSourceLines().join("\n");
         const lang = node.getAttribute("language");
@@ -145,9 +145,6 @@ var sourceCodeConverter = ({ nodeContext, transformers, template }) => {
           lang,
           transformers: [
             ...transformers ?? [],
-            (0, import_transformers.transformerNotationDiff)(),
-            (0, import_transformers.transformerNotationHighlight)(),
-            (0, import_transformers.transformerNotationFocus)(),
             transformAsciidocCallout({ node }),
             transformConsoleCodeBlock()
           ]

package/dist/lib/asciidoc/converters/index.d.cts

@@ -1,10 +1,9 @@
 import { ShikiTransformer } from 'shiki';
-import { C as CustomConverterFactoryFn, N as NodeContext } from '../../../index-Cf7MF6tZ.cjs';
+import { C as CustomConverterFactoryFn } from '../../../index-BNxO58s3.cjs';
 import 'asciidoctor';
-import 'zod';
+import 'astro/zod';
 
 type CodeBlockConverterOptions = {
-    nodeContext: NodeContext;
     transformers: ShikiTransformer[];
     template: string;
 };

package/dist/lib/asciidoc/converters/index.d.ts

@@ -1,10 +1,9 @@
 import { ShikiTransformer } from 'shiki';
-import { C as CustomConverterFactoryFn, N as NodeContext } from '../../../index-Cf7MF6tZ.js';
+import { C as CustomConverterFactoryFn } from '../../../index-BNxO58s3.js';
 import 'asciidoctor';
-import 'zod';
+import 'astro/zod';
 
 type CodeBlockConverterOptions = {
-    nodeContext: NodeContext;
     transformers: ShikiTransformer[];
     template: string;
 };

package/dist/lib/asciidoc/converters/index.js

@@ -1,6 +1,6 @@
 import {
   sourceCodeConverter
-} from "../../../chunk-HAZIHU2Y.js";
+} from "../../../chunk-BRMWIQA2.js";
 import "../../../chunk-DDIUST2Z.js";
 export {
   sourceCodeConverter

package/dist/lib/asciidoc/templates/engines/index.cjs

@@ -32,8 +32,7 @@ var engines_exports = {};
 __export(engines_exports, {
   AbstractEngine: () => AbstractEngine,
   HandlebarsEngine: () => HandlebarsEngine,
-  NunjucksEngine: () => NunjucksEngine,
-  PhpEngine: () => PhpEngine
+  NunjucksEngine: () => NunjucksEngine
 });
 module.exports = __toCommonJS(engines_exports);
 
@@ -163,29 +162,9 @@ var NunjucksEngine = class extends AbstractEngine {
     return this.render(str, options);
   }
 };
-
-// src/lib/asciidoc/templates/engines/Php.ts
-var import_php_node = require("@platformatic/php-node");
-var PhpEngine = class extends AbstractEngine {
-  server;
-  constructor(name = "php", extensions = ["php"], docroot) {
-    super(name, extensions);
-    this.server = new import_php_node.Php({ docroot });
-  }
-  renderFile(filepath, options) {
-    const request = new import_php_node.Request({
-      method: "POST",
-      url: "http://localhost/" + filepath,
-      body: Buffer.from(JSON.stringify(options))
-    });
-    const response = this.server.handleRequestSync(request);
-    return response.body.toString();
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AbstractEngine,
   HandlebarsEngine,
-  NunjucksEngine,
-  PhpEngine
+  NunjucksEngine
 });

package/dist/lib/asciidoc/templates/engines/index.d.cts

@@ -1,13 +1,13 @@
-import { b as AbstractEngine, a as AsciidocTemplate, T as TemplateModule, F as FilesystemTemplate, R as RawTemplate } from '../../../../index-Cf7MF6tZ.cjs';
-import { AbstractNode } from 'asciidoctor';
+import { b as AbstractEngine, a as AsciidocTemplate, T as TemplateModule, F as FilesystemTemplate, R as RawTemplate } from '../../../../index-BNxO58s3.cjs';
+import { AbstractBlock } from 'asciidoctor';
 import 'shiki';
-import 'zod';
+import 'astro/zod';
 
 declare class HandlebarsEngine extends AbstractEngine implements AsciidocTemplate, TemplateModule, FilesystemTemplate, RawTemplate {
     private render;
     constructor(name?: string, extensions?: string[]);
     load(): Promise<void>;
-    renderNode(node: AbstractNode, options?: Record<string, unknown>): string;
+    renderNode(node: AbstractBlock, options?: Record<string, unknown>): string;
     renderFile(filepath: string, options?: Record<string, unknown>): string;
     renderString(str: string, options?: Record<string, unknown>): string;
 }
@@ -16,15 +16,9 @@ declare class NunjucksEngine extends AbstractEngine implements AsciidocTemplate,
     private render;
     constructor(name?: string, extensions?: string[]);
     load(): Promise<void>;
-    renderNode(node: AbstractNode, options?: Record<string, unknown>): string;
+    renderNode(node: AbstractBlock, options?: Record<string, unknown>): string;
     renderFile(filepath: string, options?: Record<string, unknown>): string;
     renderString(str: string, options?: Record<string, unknown>): string;
 }
 
-declare class PhpEngine extends AbstractEngine implements FilesystemTemplate {
-    private server;
-    constructor(name: string | undefined, extensions: string[] | undefined, docroot: string);
-    renderFile(filepath: string, options?: Record<string, unknown>): string;
-}
-
-export { AbstractEngine, HandlebarsEngine, NunjucksEngine, PhpEngine };
+export { AbstractEngine, HandlebarsEngine, NunjucksEngine };

package/dist/lib/asciidoc/templates/engines/index.d.ts

@@ -1,13 +1,13 @@
-import { b as AbstractEngine, a as AsciidocTemplate, T as TemplateModule, F as FilesystemTemplate, R as RawTemplate } from '../../../../index-Cf7MF6tZ.js';
-import { AbstractNode } from 'asciidoctor';
+import { b as AbstractEngine, a as AsciidocTemplate, T as TemplateModule, F as FilesystemTemplate, R as RawTemplate } from '../../../../index-BNxO58s3.js';
+import { AbstractBlock } from 'asciidoctor';
 import 'shiki';
-import 'zod';
+import 'astro/zod';
 
 declare class HandlebarsEngine extends AbstractEngine implements AsciidocTemplate, TemplateModule, FilesystemTemplate, RawTemplate {
     private render;
     constructor(name?: string, extensions?: string[]);
     load(): Promise<void>;
-    renderNode(node: AbstractNode, options?: Record<string, unknown>): string;
+    renderNode(node: AbstractBlock, options?: Record<string, unknown>): string;
     renderFile(filepath: string, options?: Record<string, unknown>): string;
     renderString(str: string, options?: Record<string, unknown>): string;
 }
@@ -16,15 +16,9 @@ declare class NunjucksEngine extends AbstractEngine implements AsciidocTemplate,
     private render;
     constructor(name?: string, extensions?: string[]);
     load(): Promise<void>;
-    renderNode(node: AbstractNode, options?: Record<string, unknown>): string;
+    renderNode(node: AbstractBlock, options?: Record<string, unknown>): string;
     renderFile(filepath: string, options?: Record<string, unknown>): string;
     renderString(str: string, options?: Record<string, unknown>): string;
 }
 
-declare class PhpEngine extends AbstractEngine implements FilesystemTemplate {
-    private server;
-    constructor(name: string | undefined, extensions: string[] | undefined, docroot: string);
-    renderFile(filepath: string, options?: Record<string, unknown>): string;
-}
-
-export { AbstractEngine, HandlebarsEngine, NunjucksEngine, PhpEngine };
+export { AbstractEngine, HandlebarsEngine, NunjucksEngine };

package/dist/lib/asciidoc/templates/engines/index.js

@@ -3,28 +3,8 @@ import {
   HandlebarsEngine,
   NunjucksEngine
 } from "../../../../chunk-2F52PMNV.js";
-
-// src/lib/asciidoc/templates/engines/Php.ts
-import { Php, Request } from "@platformatic/php-node";
-var PhpEngine = class extends AbstractEngine {
-  server;
-  constructor(name = "php", extensions = ["php"], docroot) {
-    super(name, extensions);
-    this.server = new Php({ docroot });
-  }
-  renderFile(filepath, options) {
-    const request = new Request({
-      method: "POST",
-      url: "http://localhost/" + filepath,
-      body: Buffer.from(JSON.stringify(options))
-    });
-    const response = this.server.handleRequestSync(request);
-    return response.body.toString();
-  }
-};
 export {
   AbstractEngine,
   HandlebarsEngine,
-  NunjucksEngine,
-  PhpEngine
+  NunjucksEngine
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@d10f/asciidoc-astro-loader",
-	"version": "0.0.1",
+	"version": "0.0.2",
 	"description": "An Astro collections loader for Asciidoc files",
 	"author": "D10f",
 	"license": "MIT",
@@ -36,6 +36,7 @@
 		"./transformers": "./dist/lib/shiki/transformers/index.js"
 	},
 	"devDependencies": {
+		"astro": "^5.15.3",
 		"eslint": "^9.36.0",
 		"eslint-plugin-prettier": "^5.5.4",
 		"globals": "^16.4.0",
@@ -50,9 +51,9 @@
 	"dependencies": {
 		"@shikijs/transformers": "^3.13.0",
 		"asciidoctor": "^3.0.4",
-		"astro": "^5.14.6",
-		"shiki": "^3.13.0",
-		"ventojs": "^2.2.0",
-		"zod": "^4.1.12"
+		"shiki": "^3.13.0"
+	},
+	"peerDependencies": {
+		"astro": "^5.0.0"
 	}
 }