@stacksjs/stx 0.0.0

package/dist/loops.d.ts

@@ -0,0 +1,3 @@
+export declare function processLoops(template: string, context: Record<string, any>, filePath: string): string;
+declare const loopKeys: unknown;
+declare let whileFn: (...args: any[]) => unknown;

package/dist/markdown.d.ts

@@ -0,0 +1,2 @@
+export declare function processMarkdownDirectives(template: string, context: Record<string, any>, filePath?: string): Promise<string>;
+export declare function markdownDirectiveHandler(content: string, params: string[], _context: Record<string, any>, _filePath: string): Promise<string>;

package/dist/middleware.d.ts

@@ -0,0 +1,5 @@
+import type { StxOptions } from './types';
+
+export declare function processMiddleware(template: string, context: Record<string, any>, filePath: string, options: StxOptions, timing: 'before' | 'after'): Promise<string>;
+export declare function runPreProcessingMiddleware(template: string, context: Record<string, any>, filePath: string, options: StxOptions): Promise<string>;
+export declare function runPostProcessingMiddleware(template: string, context: Record<string, any>, filePath: string, options: StxOptions): Promise<string>;

package/dist/process.d.ts

@@ -0,0 +1,11 @@
+import type { StxOptions } from './types';
+
+export declare function processDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
+declare function processOtherDirectives(template: string, context: Record<string, any>, filePath: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
+declare function processComponentDirectives(template: string, context: Record<string, any>, filePath: string, componentsDir: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
+declare let props: {};
+declare const propsFn: unknown;
+declare const processedContent: unknown;
+declare function processCustomElements(template: string, context: Record<string, any>, filePath: string, componentsDir: string, options: StxOptions, dependencies: Set<string>): Promise<string>;
+export declare function processJsonDirective(template: string, context: Record<string, any>): string;
+export declare function processOnceDirective(template: string): string;

package/dist/src/index.js

@@ -0,0 +1,397 @@
+// @bun
+import {
+  buildWebComponents,
+  config,
+  defaultConfig,
+  docsCommand,
+  extractComponentDescription,
+  extractComponentProps,
+  findComponentFiles,
+  formatDocsAsHtml,
+  formatDocsAsJson,
+  formatDocsAsMarkdown,
+  generateComponentDoc,
+  generateComponentsDocs,
+  generateDirectivesDocs,
+  generateDocs,
+  generateTemplatesDocs,
+  webComponentDirectiveHandler
+} from "../chunk-0xkkmb8j.js";
+import {
+  applyFilters,
+  createDetailedErrorMessage,
+  createTranslateFilter,
+  defaultFilters,
+  escapeHtml,
+  evaluateAuthExpression,
+  evaluateExpression,
+  extractVariables,
+  fileExists,
+  getSourceLineInfo,
+  getTranslation,
+  loadTranslation,
+  markdownDirectiveHandler,
+  partialsCache,
+  processBasicFormDirectives,
+  processCustomDirectives,
+  processDirectives,
+  processErrorDirective,
+  processExpressions,
+  processFormDirectives,
+  processFormInputDirectives,
+  processForms,
+  processIncludes,
+  processJsonDirective,
+  processLoops,
+  processMarkdownDirectives,
+  processMiddleware,
+  processOnceDirective,
+  processStackPushDirectives,
+  processStackReplacements,
+  processTranslateDirective,
+  renderComponent,
+  resolveTemplatePath,
+  runPostProcessingMiddleware,
+  runPreProcessingMiddleware,
+  setGlobalContext,
+  unescapeHtml
+} from "../chunk-zhs1t2p5.js";
+import"../chunk-ywm063e4.js";
+
+// ../bun-plugin/src/index.ts
+import path from "path";
+var plugin = {
+  name: "bun-plugin-stx",
+  async setup(build) {
+    const options = {
+      ...defaultConfig,
+      ...build.config?.stx
+    };
+    const allDependencies = new Set;
+    const webComponentsPath = options.webComponents?.enabled ? `./${path.relative(path.dirname(build.config?.outdir || "dist"), options.webComponents.outputDir || "dist/web-components")}` : "/web-components";
+    const builtComponents = [];
+    if (options.webComponents?.enabled) {
+      try {
+        const components = await buildWebComponents(options, allDependencies);
+        builtComponents.push(...components);
+        if (options.debug && components.length > 0) {
+          console.log(`Successfully built ${components.length} web components`);
+        }
+      } catch (error) {
+        console.error("Failed to build web components:", error);
+      }
+    }
+    build.onLoad({ filter: /\.stx$/ }, async ({ path: filePath }) => {
+      try {
+        const dependencies = new Set;
+        if (options.cache && options.cachePath) {
+          const cachedOutput = await checkCache(filePath, options);
+          if (cachedOutput) {
+            if (options.debug) {
+              console.log(`Using cached version of ${filePath}`);
+            }
+            return {
+              contents: cachedOutput,
+              loader: "html"
+            };
+          }
+        }
+        const content = await Bun.file(filePath).text();
+        const scriptMatch = content.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i);
+        const scriptContent = scriptMatch ? scriptMatch[1] : "";
+        const templateContent = content.replace(/<script\b[^>]*>[\s\S]*?<\/script>/i, "");
+        const context = {
+          __filename: filePath,
+          __dirname: path.dirname(filePath),
+          __stx: {
+            webComponentsPath,
+            builtComponents
+          }
+        };
+        await extractVariables(scriptContent, context, filePath);
+        let output = templateContent;
+        output = await processDirectives(output, context, filePath, options, dependencies);
+        dependencies.forEach((dep) => allDependencies.add(dep));
+        if (options.cache && options.cachePath) {
+          await cacheTemplate(filePath, output, dependencies, options);
+          if (options.debug) {
+            console.log(`Cached template ${filePath} with ${dependencies.size} dependencies`);
+          }
+        }
+        return {
+          contents: output,
+          loader: "html"
+        };
+      } catch (error) {
+        console.error("STX Plugin Error:", error);
+        return {
+          contents: `<!DOCTYPE html><html><body><h1>STX Rendering Error</h1><pre>${error.message || String(error)}</pre></body></html>`,
+          loader: "html"
+        };
+      }
+    });
+  }
+};
+// src/caching.ts
+import fs from "fs";
+import path2 from "path";
+var templateCache = new Map;
+async function checkCache(filePath, options) {
+  try {
+    const cachePath = path2.resolve(options.cachePath);
+    const cacheFile = path2.join(cachePath, `${hashFilePath(filePath)}.html`);
+    const metaFile = path2.join(cachePath, `${hashFilePath(filePath)}.meta.json`);
+    if (!await fileExists(cacheFile) || !await fileExists(metaFile))
+      return null;
+    const metaContent = await Bun.file(metaFile).text();
+    const meta = JSON.parse(metaContent);
+    if (meta.cacheVersion !== options.cacheVersion)
+      return null;
+    const stats = await fs.promises.stat(filePath);
+    if (stats.mtime.getTime() > meta.mtime)
+      return null;
+    for (const dep of meta.dependencies) {
+      if (await fileExists(dep)) {
+        const depStats = await fs.promises.stat(dep);
+        if (depStats.mtime.getTime() > meta.mtime)
+          return null;
+      } else {
+        return null;
+      }
+    }
+    return await Bun.file(cacheFile).text();
+  } catch (err) {
+    console.warn(`Cache error for ${filePath}:`, err);
+    return null;
+  }
+}
+async function cacheTemplate(filePath, output, dependencies, options) {
+  try {
+    const cachePath = path2.resolve(options.cachePath);
+    await fs.promises.mkdir(cachePath, { recursive: true });
+    const cacheFile = path2.join(cachePath, `${hashFilePath(filePath)}.html`);
+    const metaFile = path2.join(cachePath, `${hashFilePath(filePath)}.meta.json`);
+    const stats = await fs.promises.stat(filePath);
+    await Bun.write(cacheFile, output);
+    const meta = {
+      sourcePath: filePath,
+      mtime: stats.mtime.getTime(),
+      dependencies: Array.from(dependencies),
+      cacheVersion: options.cacheVersion,
+      generatedAt: Date.now()
+    };
+    await Bun.write(metaFile, JSON.stringify(meta, null, 2));
+    templateCache.set(filePath, {
+      output,
+      mtime: stats.mtime.getTime(),
+      dependencies
+    });
+  } catch (err) {
+    console.warn(`Failed to cache template ${filePath}:`, err);
+  }
+}
+function hashFilePath(filePath) {
+  const hash = new Bun.CryptoHasher("sha1").update(filePath).digest("hex");
+  return hash.substring(0, 16);
+}
+// src/streaming.ts
+import path3 from "path";
+var defaultStreamingConfig = {
+  enabled: true,
+  bufferSize: 1024 * 16,
+  strategy: "auto",
+  timeout: 30000
+};
+var SECTION_PATTERN = /<!-- @section:([a-zA-Z0-9_-]+) -->([\s\S]*?)<!-- @endsection:\1 -->/g;
+async function streamTemplate(templatePath, data = {}, options = {}) {
+  const fullOptions = {
+    ...defaultConfig,
+    ...options,
+    streaming: {
+      ...defaultStreamingConfig,
+      ...options.streaming
+    }
+  };
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        const content = await Bun.file(templatePath).text();
+        const scriptMatch = content.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i);
+        const scriptContent = scriptMatch ? scriptMatch[1] : "";
+        const templateContent = content.replace(/<script\b[^>]*>[\s\S]*?<\/script>/i, "");
+        const context = {
+          ...data,
+          __filename: templatePath,
+          __dirname: path3.dirname(templatePath)
+        };
+        await extractVariables(scriptContent, context, templatePath);
+        const dependencies = new Set;
+        const output = await processDirectives(templateContent, context, templatePath, fullOptions, dependencies);
+        controller.enqueue(output);
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  });
+}
+async function createStreamRenderer(templatePath, options = {}) {
+  const fullOptions = {
+    ...defaultConfig,
+    ...options,
+    streaming: {
+      ...defaultStreamingConfig,
+      ...options.streaming
+    }
+  };
+  let content = await Bun.file(templatePath).text();
+  const scriptMatch = content.match(/<script\b[^>]*>([\s\S]*?)<\/script>/i);
+  const scriptContent = scriptMatch ? scriptMatch[1] : "";
+  const templateContent = content.replace(/<script\b[^>]*>[\s\S]*?<\/script>/i, "");
+  const originalTemplate = templateContent;
+  const sections = {};
+  let match;
+  SECTION_PATTERN.lastIndex = 0;
+  while ((match = SECTION_PATTERN.exec(templateContent)) !== null) {
+    const sectionName = match[1];
+    const sectionContent = match[2];
+    sections[sectionName] = sectionContent;
+  }
+  let shellTemplate = templateContent.replace(SECTION_PATTERN, "");
+  const renderer = {
+    renderShell: async (data = {}) => {
+      const context = {
+        ...data,
+        __filename: templatePath,
+        __dirname: path3.dirname(templatePath)
+      };
+      await extractVariables(scriptContent, context, templatePath);
+      const dependencies = new Set;
+      return processDirectives(shellTemplate, context, templatePath, fullOptions, dependencies);
+    },
+    renderSection: async (sectionName, data = {}) => {
+      try {
+        if (!sections[sectionName]) {
+          return `<div class="error-message">Section "${sectionName}" not found in template "${templatePath}"</div>`;
+        }
+        const context = {
+          ...data,
+          __filename: templatePath,
+          __dirname: path3.dirname(templatePath)
+        };
+        await extractVariables(scriptContent, context, templatePath);
+        const dependencies = new Set;
+        return await processDirectives(sections[sectionName], context, templatePath, fullOptions, dependencies);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return createDetailedErrorMessage("Expression", errorMessage, templatePath, sections[sectionName] || "", 0, sections[sectionName] || "");
+      }
+    },
+    getSections: () => {
+      return Object.keys(sections);
+    },
+    getTemplate: () => {
+      return originalTemplate;
+    }
+  };
+  return renderer;
+}
+var islandDirective = {
+  name: "island",
+  hasEndTag: true,
+  handler: (content, params, context, filePath) => {
+    if (!params || params.length === 0) {
+      throw new Error("Island directive requires a name parameter");
+    }
+    const islandName = params[0].replace(/['"`]/g, "");
+    const priority = params[1] ? params[1].replace(/['"`]/g, "") : "lazy";
+    const id = `island-${islandName}-${Math.random().toString(36).substring(2, 9)}`;
+    const propsMatch = content.match(/<script\s+props\s*>([\s\S]*?)<\/script>/i);
+    const propsScript = propsMatch ? propsMatch[1].trim() : "";
+    const contentWithoutProps = propsMatch ? content.replace(propsMatch[0], "") : content;
+    return `<div data-island="${islandName}" data-island-id="${id}" data-priority="${priority}">
+      ${contentWithoutProps}
+      <script type="application/json" data-island-props="${id}">
+        ${propsScript ? `{${propsScript}}` : "{}"}
+      </script>
+    </div>`;
+  }
+};
+function registerStreamingDirectives(options = {}) {
+  const directives = [];
+  if (options.hydration?.enabled) {
+    directives.push(islandDirective);
+  }
+  return directives;
+}
+async function processSectionDirectives(content, context, filePath, options = {}) {
+  return content;
+}
+
+// src/index.ts
+var src_default = plugin;
+export {
+  webComponentDirectiveHandler,
+  unescapeHtml,
+  templateCache,
+  streamTemplate,
+  setGlobalContext,
+  runPreProcessingMiddleware,
+  runPostProcessingMiddleware,
+  resolveTemplatePath,
+  renderComponent,
+  registerStreamingDirectives,
+  processTranslateDirective,
+  processStackReplacements,
+  processStackPushDirectives,
+  processSectionDirectives,
+  processOnceDirective,
+  processMiddleware,
+  processMarkdownDirectives,
+  processLoops,
+  processJsonDirective,
+  processIncludes,
+  processForms,
+  processFormInputDirectives,
+  processFormDirectives,
+  processExpressions,
+  processErrorDirective,
+  processDirectives,
+  processCustomDirectives,
+  processBasicFormDirectives,
+  partialsCache,
+  markdownDirectiveHandler,
+  loadTranslation,
+  islandDirective,
+  hashFilePath,
+  getTranslation,
+  getSourceLineInfo,
+  generateTemplatesDocs,
+  generateDocs,
+  generateDirectivesDocs,
+  generateComponentsDocs,
+  generateComponentDoc,
+  formatDocsAsMarkdown,
+  formatDocsAsJson,
+  formatDocsAsHtml,
+  findComponentFiles,
+  fileExists,
+  extractVariables,
+  extractComponentProps,
+  extractComponentDescription,
+  evaluateExpression,
+  evaluateAuthExpression,
+  escapeHtml,
+  docsCommand,
+  defaultFilters,
+  defaultConfig,
+  src_default as default,
+  createTranslateFilter,
+  createStreamRenderer,
+  createDetailedErrorMessage,
+  config,
+  checkCache,
+  cacheTemplate,
+  buildWebComponents,
+  applyFilters
+};

package/dist/streaming.d.ts

@@ -0,0 +1,14 @@
+import type { CustomDirective, StreamRenderer, StreamingConfig, StxOptions } from './types';
+
+declare const defaultStreamingConfig: StreamingConfig;
+export declare function streamTemplate(templatePath: string,
+  data: Record<string, any> = {},
+  options: StxOptions = {},): Promise<ReadableStream<string>>;
+export declare function createStreamRenderer(templatePath: string,
+  options: StxOptions = {},): Promise<StreamRenderer>;
+export declare const islandDirective: CustomDirective;
+export declare function registerStreamingDirectives(options: StxOptions = {}): CustomDirective[];
+export declare function processSectionDirectives(content: string,
+  context: Record<string, any>,
+  filePath: string,
+  options: StxOptions = {},): Promise<string>;

package/dist/types.d.ts

@@ -0,0 +1,149 @@
+export declare type CustomDirectiveHandler = (
+  content: string,
+  params: string[],
+  context: Record<string, any>,
+  filePath: string
+) => string | Promise<string>
+
+export interface CustomDirective {
+  name: string
+  handler: CustomDirectiveHandler
+  hasEndTag?: boolean
+  description?: string
+}
+
+export type MiddlewareHandler = (
+  template: string,
+  context: Record<string, any>,
+  filePath: string,
+  options: StxOptions
+) => string | Promise<string>
+
+export interface Middleware {
+  name: string
+  handler: MiddlewareHandler
+  timing: 'before' | 'after'
+  description?: string
+}
+
+export interface I18nConfig {
+  defaultLocale: string
+  locale: string
+  translationsDir: string
+  format: 'json' | 'yaml' | 'yml' | 'js'
+  fallbackToKey: boolean
+  cache: boolean
+}
+
+export interface WebComponent {
+  name: string
+  tag: string
+  file: string
+  extends?: string
+  shadowDOM?: boolean
+  template?: boolean
+  styleSource?: string
+  attributes?: string[]
+  description?: string
+}
+
+export interface WebComponentConfig {
+  enabled: boolean
+  outputDir: string
+  components: WebComponent[]
+}
+
+export type DocFormat = 'markdown' | 'html' | 'json'
+
+export interface ComponentPropDoc {
+  name: string
+  type?: string
+  required?: boolean
+  default?: string
+  description?: string
+}
+
+export interface ComponentDoc {
+  name: string
+  path: string
+  description?: string
+  props: ComponentPropDoc[]
+  example?: string
+  isWebComponent?: boolean
+  tag?: string
+}
+
+export interface TemplateDoc {
+  name: string
+  path: string
+  description?: string
+  components?: string[]
+  directives?: string[]
+}
+
+export interface DirectiveDoc {
+  name: string
+  description?: string
+  hasEndTag: boolean
+  example?: string
+}
+
+export interface DocGeneratorConfig {
+  enabled: boolean
+  outputDir: string
+  format: DocFormat
+  components: boolean
+  templates: boolean
+  directives: boolean
+  extraContent?: string
+  template?: string
+}
+
+export interface StreamingConfig {
+  enabled: boolean
+  bufferSize: number
+  strategy: 'auto' | 'manual' | 'sections'
+  timeout: number
+}
+
+export interface StreamRenderer {
+  renderShell: (data?: Record<string, any>) => Promise<string>
+  renderSection: (section: string, data?: Record<string, any>) => Promise<string>
+  getSections: () => string[]
+  getTemplate: () => string
+}
+
+export interface HydrationConfig {
+  enabled: boolean
+  mode: 'progressive' | 'islands'
+  clientEntry: string
+  autoMarkers: boolean
+  preload: 'none' | 'eager' | 'lazy'
+}
+
+export interface Island {
+  id: string
+  component: string
+  props?: Record<string, any>
+  priority?: 'eager' | 'lazy'
+  shadowDOM?: boolean
+}
+
+export interface StxConfig {
+  enabled: boolean
+  partialsDir: string
+  componentsDir: string
+  debug: boolean
+  cache: boolean
+  cachePath: string
+  cacheVersion: string
+  customDirectives?: CustomDirective[]
+  middleware?: Middleware[]
+  i18n?: Partial<I18nConfig>
+  webComponents?: Partial<WebComponentConfig>
+  docs?: Partial<DocGeneratorConfig>
+  streaming?: Partial<StreamingConfig>
+  hydration?: Partial<HydrationConfig>
+}
+
+export type StxOptions = Partial<StxConfig>

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+import type { StxOptions } from './types';
+
+declare const componentsCache: (...args: any[]) => unknown;
+export declare function renderComponent(componentPath: string, props: Record<string, any>, slotContent: string, componentsDir: string, parentContext: Record<string, any>, parentFilePath: string, options: StxOptions, processedComponents?: Set<string> | undefined, dependencies: Set<string>): Promise<string>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function extractVariables(scriptContent: string, context: Record<string, any>, filePath: string): Promise<void>;
+export declare function resolveTemplatePath(templatePath: string, currentFilePath: string, options: StxOptions, dependencies?: Set<string>): Promise<string | null>;
+export declare function getSourceLineInfo(template: string, errorPosition?: number, errorPattern?: string): void;
+export declare function createDetailedErrorMessage(errorType: string, errorMessage: string, filePath: string, template: string, errorPosition?: number, errorPattern?: string): string;

package/dist/web-components.d.ts

@@ -0,0 +1,16 @@
+import type { StxOptions, WebComponent } from './types';
+
+export declare function buildWebComponents(options: StxOptions, dependencies: Set<string>): Promise<string[]>;
+declare function buildWebComponent(component: WebComponent, options: StxOptions, dependencies: Set<string>): Promise<string | null>;
+declare interface WebComponentCodeOptions {
+  name: string
+  tag: string
+  baseElement?: string
+  source: string
+  shadowDOM: boolean
+  template: boolean
+  styleSource?: string
+  attributes?: string[]
+}
+declare function generateWebComponentCode(options: WebComponentCodeOptions): string;
+export declare function webComponentDirectiveHandler(content: string, params: string[], context: Record<string, any>, _filePath: string): string;

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@stacksjs/stx",
+  "type": "module",
+  "version": "0.0.0",
+  "description": "A Bun plugin that allows for using Laravel Blade-like syntax.",
+  "author": "Chris Breuer <chris@stacksjs.org>",
+  "license": "MIT",
+  "homepage": "https://github.com/stacksjs/stx#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stacksjs/stx.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stacksjs/stx/issues"
+  },
+  "keywords": [
+    "blade",
+    "css",
+    "bun",
+    "stx",
+    "plugin",
+    "generation",
+    "typescript",
+    "stacks"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "import": "./dist/*"
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "stx": "./dist/bin/cli.js"
+  },
+  "files": [
+    "LICENSE.md",
+    "README.md",
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun --bun build.ts && bun run compile",
+    "compile": "bun build ./bin/cli.ts --compile --minify --outfile ./bin/stx",
+    "compile:all": "bun run compile:linux-x64 && bun run compile:linux-arm64 && bun run compile:windows-x64 && bun run compile:darwin-x64 && bun run compile:darwin-arm64",
+    "compile:linux-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-linux-x64 --outfile ./bin/stx-linux-x64",
+    "compile:linux-arm64": "bun build ./bin/cli.ts --compile --minify --target=bun-linux-arm64 --outfile ./bin/stx-linux-arm64",
+    "compile:windows-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-windows-x64 --outfile ./bin/stx-windows-x64.exe",
+    "compile:darwin-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-darwin-x64 --outfile ./bin/stx-darwin-x64",
+    "compile:darwin-arm64": "bun build ./bin/cli.ts --compile --minify --target=bun-darwin-arm64 --outfile ./bin/stx-darwin-arm64",
+    "zip": "bun run zip:all",
+    "zip:all": "bun run zip:linux-x64 && bun run zip:linux-arm64 && bun run zip:windows-x64 && bun run zip:darwin-x64 && bun run zip:darwin-arm64",
+    "zip:linux-x64": "zip -j bin/stx-linux-x64.zip bin/stx-linux-x64",
+    "zip:linux-arm64": "zip -j bin/stx-linux-arm64.zip bin/stx-linux-arm64",
+    "zip:windows-x64": "zip -j bin/stx-windows-x64.zip bin/stx-windows-x64.exe",
+    "zip:darwin-x64": "zip -j bin/stx-darwin-x64.zip bin/stx-darwin-x64",
+    "zip:darwin-arm64": "zip -j bin/stx-darwin-arm64.zip bin/stx-darwin-arm64",
+    "lint": "bunx eslint .",
+    "lint:fix": "bunx eslint . --fix",
+    "fresh": "bunx rimraf node_modules/ bun.lock && bun i",
+    "changelog": "bunx changelogen --output CHANGELOG.md",
+    "prepublishOnly": "bun run build",
+    "release": "bun run changelog && bunx bumpp package.json --all",
+    "test": "bun test",
+    "typecheck": "bun tsc --noEmit"
+  },
+  "dependencies": {
+    "marked": "^15.0.11",
+    "yaml": "^2.7.1"
+  }
+}