@staticbolt/core 1.0.0-beta.0

package/lib/index.d.mts

@@ -0,0 +1,1734 @@
+import { basename, extname, isAbsolute, parse, resolve } from "node:path";
+import { Document, HTMLElement, HTMLElement as HTMLElement$1, Node } from "@staticbolt/node-html-parser";
+import postcss, { Node as Node$1, Postcss } from "postcss";
+import { NodePath as NodePath$1 } from "@babel/traverse";
+import { ObjectEncodingOptions, OpenMode, PathLike, PathOrFileDescriptor } from "node:fs";
+import { FileHandle } from "node:fs/promises";
+import * as t from "@babel/types";
+import { Node as Node$2 } from "@babel/types";
+import { ParseResult } from "@babel/parser";
+import { onRequestHookHandler } from "fastify";
+import { FSWatcher } from "chokidar";
+import * as z from "zod";
+import * as _$_staticbolt_args_parser0 from "@staticbolt/args-parser";
+import { Argument, Option, Subcommand, defineArguments, defineOptions, defineSubcommand } from "@staticbolt/args-parser";
+import { App as App$1, AppConfig as AppConfig$1, BabelAst as BabelAst$1, BinaryAssetMetadata as BinaryAssetMetadata$1, CliProgram as CliProgram$1, Document as Document$1, HTMLElement as HTMLElement$2, HtmlMetadata as HtmlMetadata$1, MarkdownAst as MarkdownAst$1, MarkdownMetadata as MarkdownMetadata$1, MetadataBase as MetadataBase$1, MetadataSource as MetadataSource$1, PackageMetadata as PackageMetadata$1, Plugin as Plugin$1, PostcssAst as PostcssAst$1, ScriptMetadata as ScriptMetadata$1, ServerReply as ServerReply$1, ServerRequest as ServerRequest$1, StyleMetadata as StyleMetadata$1, SvgMetadata as SvgMetadata$1, TextAssetMetadata as TextAssetMetadata$1, WebManifestMetadata as WebManifestMetadata$1 } from "@staticbolt/core";
+import { ImageResource, WebAppManifest } from "web-app-manifest";
+import { Abortable } from "node:events";
+
+//#region ../../node_modules/@types/unist/index.d.ts
+// ## Interfaces
+/**
+ * Info associated with nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or specifications
+ * implementing unist.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'unist' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+interface Data$1 {}
+/**
+ * One place in a source file.
+ */
+interface Point {
+  /**
+   * Line in a source file (1-indexed integer).
+   */
+  line: number;
+  /**
+   * Column in a source file (1-indexed integer).
+   */
+  column: number;
+  /**
+   * Character in a source file (0-indexed integer).
+   */
+  offset?: number | undefined;
+}
+/**
+ * Position of a node in a source document.
+ *
+ * A position is a range between two points.
+ */
+interface Position {
+  /**
+   * Place of the first character of the parsed source region.
+   */
+  start: Point;
+  /**
+   * Place of the first character after the parsed source region.
+   */
+  end: Point;
+}
+/**
+ * Abstract unist node.
+ *
+ * The syntactic unit in unist syntax trees are called nodes.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in markdown, a `thematicBreak` (`***`), is neither literal
+ * nor parent, but still a node.
+ */
+interface Node$5 {
+  /**
+   * Node type.
+   */
+  type: string;
+  /**
+   * Info from the ecosystem.
+   */
+  data?: Data$1 | undefined;
+  /**
+   * Position of a node in a source document.
+   *
+   * Nodes that are generated (not in the original source document) must not
+   * have a position.
+   */
+  position?: Position | undefined;
+}
+//#endregion
+//#region ../../node_modules/@types/mdast/index.d.ts
+// ## Enumeration
+/**
+ * How phrasing content is aligned
+ * ({@link https://drafts.csswg.org/css-text/ | [CSSTEXT]}).
+ *
+ * * `'left'`: See the
+ *   {@link https://drafts.csswg.org/css-text/#valdef-text-align-left | left}
+ *   value of the `text-align` CSS property
+ * * `'right'`: See the
+ *   {@link https://drafts.csswg.org/css-text/#valdef-text-align-right | right}
+ *   value of the `text-align` CSS property
+ * * `'center'`: See the
+ *   {@link https://drafts.csswg.org/css-text/#valdef-text-align-center | center}
+ *   value of the `text-align` CSS property
+ * * `null`: phrasing content is aligned as defined by the host environment
+ *
+ * Used in GFM tables.
+ */
+type AlignType = "center" | "left" | "right" | null;
+/**
+ * Explicitness of a reference.
+ *
+ * `'shortcut'`: the reference is implicit, its identifier inferred from its
+ *   content
+ * `'collapsed'`: the reference is explicit, its identifier inferred from its
+ *   content
+ * `'full'`: the reference is explicit, its identifier explicitly set
+ */
+type ReferenceType = "shortcut" | "collapsed" | "full";
+// ## Mixin
+/**
+ * Node with a fallback.
+ */
+interface Alternative {
+  /**
+   * Equivalent content for environments that cannot represent the node as
+   * intended.
+   */
+  alt?: string | null | undefined;
+}
+/**
+ * Internal relation from one node to another.
+ *
+ * Whether the value of `identifier` is expected to be a unique identifier or
+ * not depends on the type of node including the Association.
+ * An example of this is that they should be unique on {@link Definition},
+ * whereas multiple {@link LinkReference}s can be non-unique to be associated
+ * with one definition.
+ */
+interface Association {
+  /**
+   * Relation of association.
+   *
+   * `identifier` is a source value: character escapes and character
+   * references are not parsed.
+   *
+   * It can match another node.
+   *
+   * Its value must be normalized.
+   * To normalize a value, collapse markdown whitespace (`[\t\n\r ]+`) to a space,
+   * trim the optional initial and/or final space, and perform Unicode-aware
+   * case-folding.
+   */
+  identifier: string;
+  /**
+   * Relation of association, in parsed form.
+   *
+   * `label` is a `string` value: it works just like `title` on {@link Link}
+   * or a `lang` on {@link Code}: character escapes and character references
+   * are parsed.
+   *
+   * It can match another node.
+   */
+  label?: string | null | undefined;
+}
+/**
+ * Marker that is associated to another node.
+ */
+interface Reference extends Association {
+  /**
+   * Explicitness of the reference.
+   */
+  referenceType: ReferenceType;
+}
+/**
+ * Reference to resource.
+ */
+interface Resource {
+  /**
+   * URL to the referenced resource.
+   */
+  url: string;
+  /**
+   * Advisory information for the resource, such as would be appropriate for
+   * a tooltip.
+   */
+  title?: string | null | undefined;
+}
+// ## Interfaces
+/**
+ * Info associated with mdast nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or mdast.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'mdast' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+interface Data extends Data$1 {}
+// ## Content maps
+/**
+ * Union of registered mdast nodes that can occur where block content is
+ * expected.
+ *
+ * To register custom mdast nodes, add them to {@link BlockContentMap}.
+ * They will be automatically added here.
+ */
+type BlockContent = BlockContentMap[keyof BlockContentMap];
+/**
+ * Registry of all mdast nodes that can occur where {@link BlockContent} is
+ * expected.
+ *
+ * This interface can be augmented to register custom node types:
+ *
+ * ```ts
+ * declare module 'mdast' {
+ *   interface BlockContentMap {
+ *     // Allow using MDX ESM nodes defined by `remark-mdx`.
+ *     mdxjsEsm: MdxjsEsm;
+ *   }
+ * }
+ * ```
+ *
+ * For a union of all block content, see {@link RootContent}.
+ */
+interface BlockContentMap {
+  blockquote: Blockquote;
+  code: Code;
+  heading: Heading;
+  html: Html;
+  list: List;
+  paragraph: Paragraph;
+  table: Table;
+  thematicBreak: ThematicBreak;
+}
+/**
+ * Union of registered mdast nodes that can occur where definition content is
+ * expected.
+ *
+ * To register custom mdast nodes, add them to {@link DefinitionContentMap}.
+ * They will be automatically added here.
+ */
+type DefinitionContent = DefinitionContentMap[keyof DefinitionContentMap];
+/**
+ * Registry of all mdast nodes that can occur where {@link DefinitionContent}
+ * is expected.
+ *
+ * This interface can be augmented to register custom node types:
+ *
+ * ```ts
+ * declare module 'mdast' {
+ *   interface DefinitionContentMap {
+ *     custom: Custom;
+ *   }
+ * }
+ * ```
+ *
+ * For a union of all definition content, see {@link RootContent}.
+ */
+interface DefinitionContentMap {
+  definition: Definition;
+  footnoteDefinition: FootnoteDefinition;
+}
+/**
+ * Union of registered mdast nodes that can occur where list content is
+ * expected.
+ *
+ * To register custom mdast nodes, add them to {@link ListContentMap}.
+ * They will be automatically added here.
+ */
+type ListContent = ListContentMap[keyof ListContentMap];
+/**
+ * Registry of all mdast nodes that can occur where {@link ListContent}
+ * is expected.
+ *
+ * This interface can be augmented to register custom node types:
+ *
+ * ```ts
+ * declare module 'mdast' {
+ *   interface ListContentMap {
+ *     custom: Custom;
+ *   }
+ * }
+ * ```
+ *
+ * For a union of all list content, see {@link RootContent}.
+ */
+interface ListContentMap {
+  listItem: ListItem;
+}
+/**
+ * Union of registered mdast nodes that can occur where phrasing content is
+ * expected.
+ *
+ * To register custom mdast nodes, add them to {@link PhrasingContentMap}.
+ * They will be automatically added here.
+ */
+type PhrasingContent = PhrasingContentMap[keyof PhrasingContentMap];
+/**
+ * Registry of all mdast nodes that can occur where {@link PhrasingContent}
+ * is expected.
+ *
+ * This interface can be augmented to register custom node types:
+ *
+ * ```ts
+ * declare module 'mdast' {
+ *   interface PhrasingContentMap {
+ *     // Allow using MDX JSX (text) nodes defined by `remark-mdx`.
+ *     mdxJsxTextElement: MDXJSXTextElement;
+ *   }
+ * }
+ * ```
+ *
+ * For a union of all phrasing content, see {@link RootContent}.
+ */
+interface PhrasingContentMap {
+  break: Break;
+  delete: Delete;
+  emphasis: Emphasis;
+  footnoteReference: FootnoteReference;
+  html: Html;
+  image: Image;
+  imageReference: ImageReference;
+  inlineCode: InlineCode;
+  link: Link;
+  linkReference: LinkReference;
+  strong: Strong;
+  text: Text;
+}
+/**
+ * Union of registered mdast nodes that can occur in {@link Root}.
+ *
+ * To register custom mdast nodes, add them to {@link RootContentMap}.
+ * They will be automatically added here.
+ */
+type RootContent = RootContentMap[keyof RootContentMap];
+/**
+ * Registry of all mdast nodes that can occur as children of {@link Root}.
+ *
+ * > **Note**: {@link Root} does not need to be an entire document.
+ * > it can also be a fragment.
+ *
+ * This interface can be augmented to register custom node types:
+ *
+ * ```ts
+ * declare module 'mdast' {
+ *   interface RootContentMap {
+ *     // Allow using toml nodes defined by `remark-frontmatter`.
+ *     toml: TOML;
+ *   }
+ * }
+ * ```
+ *
+ * For a union of all {@link Root} children, see {@link RootContent}.
+ */
+interface RootContentMap {
+  blockquote: Blockquote;
+  break: Break;
+  code: Code;
+  definition: Definition;
+  delete: Delete;
+  emphasis: Emphasis;
+  footnoteDefinition: FootnoteDefinition;
+  footnoteReference: FootnoteReference;
+  heading: Heading;
+  html: Html;
+  image: Image;
+  imageReference: ImageReference;
+  inlineCode: InlineCode;
+  link: Link;
+  linkReference: LinkReference;
+  list: List;
+  listItem: ListItem;
+  paragraph: Paragraph;
+  strong: Strong;
+  table: Table;
+  tableCell: TableCell;
+  tableRow: TableRow;
+  text: Text;
+  thematicBreak: ThematicBreak;
+  yaml: Yaml;
+}
+/**
+ * Union of registered mdast nodes that can occur where row content is
+ * expected.
+ *
+ * To register custom mdast nodes, add them to {@link RowContentMap}.
+ * They will be automatically added here.
+ */
+type RowContent = RowContentMap[keyof RowContentMap];
+/**
+ * Registry of all mdast nodes that can occur where {@link RowContent}
+ * is expected.
+ *
+ * This interface can be augmented to register custom node types:
+ *
+ * ```ts
+ * declare module 'mdast' {
+ *   interface RowContentMap {
+ *     custom: Custom;
+ *   }
+ * }
+ * ```
+ *
+ * For a union of all row content, see {@link RootContent}.
+ */
+interface RowContentMap {
+  tableCell: TableCell;
+}
+/**
+ * Union of registered mdast nodes that can occur where table content is
+ * expected.
+ *
+ * To register custom mdast nodes, add them to {@link TableContentMap}.
+ * They will be automatically added here.
+ */
+type TableContent = TableContentMap[keyof TableContentMap];
+/**
+ * Registry of all mdast nodes that can occur where {@link TableContent}
+ * is expected.
+ *
+ * This interface can be augmented to register custom node types:
+ *
+ * ```ts
+ * declare module 'mdast' {
+ *   interface TableContentMap {
+ *     custom: Custom;
+ *   }
+ * }
+ * ```
+ *
+ * For a union of all table content, see {@link RootContent}.
+ */
+interface TableContentMap {
+  tableRow: TableRow;
+}
+// ## Abstract nodes
+/**
+ * Abstract mdast node that contains the smallest possible value.
+ *
+ * This interface is supposed to be extended if you make custom mdast nodes.
+ *
+ * For a union of all registered mdast literals, see {@link Literals}.
+ */
+interface Literal extends Node$4 {
+  /**
+   * Plain-text value.
+   */
+  value: string;
+}
+/**
+ * Abstract mdast node.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in markdown, a thematic break (`***`) is neither literal nor
+ * parent, but still a node.
+ *
+ * To register custom mdast nodes, add them to {@link RootContentMap} and other
+ * places where relevant (such as {@link ElementContentMap}).
+ *
+ * For a union of all registered mdast nodes, see {@link Nodes}.
+ */
+interface Node$4 extends Node$5 {
+  /**
+   * Info from the ecosystem.
+   */
+  data?: Data | undefined;
+}
+/**
+ * Abstract mdast node that contains other mdast nodes (*children*).
+ *
+ * This interface is supposed to be extended if you make custom mdast nodes.
+ *
+ * For a union of all registered mdast parents, see {@link Parents}.
+ */
+interface Parent extends Node$4 {
+  /**
+   * List of children.
+   */
+  children: RootContent[];
+}
+// ## Concrete nodes
+/**
+ * Markdown block quote.
+ */
+interface Blockquote extends Parent {
+  /**
+   * Node type of mdast block quote.
+   */
+  type: "blockquote";
+  /**
+   * Children of block quote.
+   */
+  children: Array<BlockContent | DefinitionContent>;
+  /**
+   * Data associated with the mdast block quote.
+   */
+  data?: BlockquoteData | undefined;
+}
+/**
+ * Info associated with mdast block quote nodes by the ecosystem.
+ */
+interface BlockquoteData extends Data {}
+/**
+ * Markdown break.
+ */
+interface Break extends Node$4 {
+  /**
+   * Node type of mdast break.
+   */
+  type: "break";
+  /**
+   * Data associated with the mdast break.
+   */
+  data?: BreakData | undefined;
+}
+/**
+ * Info associated with mdast break nodes by the ecosystem.
+ */
+interface BreakData extends Data {}
+/**
+ * Markdown code (flow) (block).
+ */
+interface Code extends Literal {
+  /**
+   * Node type of mdast code (flow).
+   */
+  type: "code";
+  /**
+   * Language of computer code being marked up.
+   */
+  lang?: string | null | undefined;
+  /**
+   * Custom information relating to the node.
+   *
+   * If the lang field is present, a meta field can be present.
+   */
+  meta?: string | null | undefined;
+  /**
+   * Data associated with the mdast code (flow).
+   */
+  data?: CodeData | undefined;
+}
+/**
+ * Info associated with mdast code (flow) (block) nodes by the ecosystem.
+ */
+interface CodeData extends Data {}
+/**
+ * Markdown definition.
+ */
+interface Definition extends Node$4, Association, Resource {
+  /**
+   * Node type of mdast definition.
+   */
+  type: "definition";
+  /**
+   * Data associated with the mdast definition.
+   */
+  data?: DefinitionData | undefined;
+}
+/**
+ * Info associated with mdast definition nodes by the ecosystem.
+ */
+interface DefinitionData extends Data {}
+/**
+ * Markdown GFM delete (strikethrough).
+ */
+interface Delete extends Parent {
+  /**
+   * Node type of mdast GFM delete.
+   */
+  type: "delete";
+  /**
+   * Children of GFM delete.
+   */
+  children: PhrasingContent[];
+  /**
+   * Data associated with the mdast GFM delete.
+   */
+  data?: DeleteData | undefined;
+}
+/**
+ * Info associated with mdast GFM delete nodes by the ecosystem.
+ */
+interface DeleteData extends Data {}
+/**
+ * Markdown emphasis.
+ */
+interface Emphasis extends Parent {
+  /**
+   * Node type of mdast emphasis.
+   */
+  type: "emphasis";
+  /**
+   * Children of emphasis.
+   */
+  children: PhrasingContent[];
+  /**
+   * Data associated with the mdast emphasis.
+   */
+  data?: EmphasisData | undefined;
+}
+/**
+ * Info associated with mdast emphasis nodes by the ecosystem.
+ */
+interface EmphasisData extends Data {}
+/**
+ * Markdown GFM footnote definition.
+ */
+interface FootnoteDefinition extends Parent, Association {
+  /**
+   * Node type of mdast GFM footnote definition.
+   */
+  type: "footnoteDefinition";
+  /**
+   * Children of GFM footnote definition.
+   */
+  children: Array<BlockContent | DefinitionContent>;
+  /**
+   * Data associated with the mdast GFM footnote definition.
+   */
+  data?: FootnoteDefinitionData | undefined;
+}
+/**
+ * Info associated with mdast GFM footnote definition nodes by the ecosystem.
+ */
+interface FootnoteDefinitionData extends Data {}
+/**
+ * Markdown GFM footnote reference.
+ */
+interface FootnoteReference extends Association, Node$4 {
+  /**
+   * Node type of mdast GFM footnote reference.
+   */
+  type: "footnoteReference";
+  /**
+   * Data associated with the mdast GFM footnote reference.
+   */
+  data?: FootnoteReferenceData | undefined;
+}
+/**
+ * Info associated with mdast GFM footnote reference nodes by the ecosystem.
+ */
+interface FootnoteReferenceData extends Data {}
+/**
+ * Markdown heading.
+ */
+interface Heading extends Parent {
+  /**
+   * Node type of mdast heading.
+   */
+  type: "heading";
+  /**
+   * Heading rank.
+   *
+   * A value of `1` is said to be the highest rank and `6` the lowest.
+   */
+  depth: 1 | 2 | 3 | 4 | 5 | 6;
+  /**
+   * Children of heading.
+   */
+  children: PhrasingContent[];
+  /**
+   * Data associated with the mdast heading.
+   */
+  data?: HeadingData | undefined;
+}
+/**
+ * Info associated with mdast heading nodes by the ecosystem.
+ */
+interface HeadingData extends Data {}
+/**
+ * Markdown HTML.
+ */
+interface Html extends Literal {
+  /**
+   * Node type of mdast HTML.
+   */
+  type: "html";
+  /**
+   * Data associated with the mdast HTML.
+   */
+  data?: HtmlData | undefined;
+}
+/**
+ * Info associated with mdast HTML nodes by the ecosystem.
+ */
+interface HtmlData extends Data {}
+/**
+ * Markdown image.
+ */
+interface Image extends Alternative, Node$4, Resource {
+  /**
+   * Node type of mdast image.
+   */
+  type: "image";
+  /**
+   * Data associated with the mdast image.
+   */
+  data?: ImageData | undefined;
+}
+/**
+ * Info associated with mdast image nodes by the ecosystem.
+ */
+interface ImageData extends Data {}
+/**
+ * Markdown image reference.
+ */
+interface ImageReference extends Alternative, Node$4, Reference {
+  /**
+   * Node type of mdast image reference.
+   */
+  type: "imageReference";
+  /**
+   * Data associated with the mdast image reference.
+   */
+  data?: ImageReferenceData | undefined;
+}
+/**
+ * Info associated with mdast image reference nodes by the ecosystem.
+ */
+interface ImageReferenceData extends Data {}
+/**
+ * Markdown code (text) (inline).
+ */
+interface InlineCode extends Literal {
+  /**
+   * Node type of mdast code (text).
+   */
+  type: "inlineCode";
+  /**
+   * Data associated with the mdast code (text).
+   */
+  data?: InlineCodeData | undefined;
+}
+/**
+ * Info associated with mdast code (text) (inline) nodes by the ecosystem.
+ */
+interface InlineCodeData extends Data {}
+/**
+ * Markdown link.
+ */
+interface Link extends Parent, Resource {
+  /**
+   * Node type of mdast link.
+   */
+  type: "link";
+  /**
+   * Children of link.
+   */
+  children: PhrasingContent[];
+  /**
+   * Data associated with the mdast link.
+   */
+  data?: LinkData | undefined;
+}
+/**
+ * Info associated with mdast link nodes by the ecosystem.
+ */
+interface LinkData extends Data {}
+/**
+ * Markdown link reference.
+ */
+interface LinkReference extends Parent, Reference {
+  /**
+   * Node type of mdast link reference.
+   */
+  type: "linkReference";
+  /**
+   * Children of link reference.
+   */
+  children: PhrasingContent[];
+  /**
+   * Data associated with the mdast link reference.
+   */
+  data?: LinkReferenceData | undefined;
+}
+/**
+ * Info associated with mdast link reference nodes by the ecosystem.
+ */
+interface LinkReferenceData extends Data {}
+/**
+ * Markdown list.
+ */
+interface List extends Parent {
+  /**
+   * Node type of mdast list.
+   */
+  type: "list";
+  /**
+   * Whether the items have been intentionally ordered (when `true`), or that
+   * the order of items is not important (when `false` or not present).
+   */
+  ordered?: boolean | null | undefined;
+  /**
+   * The starting number of the list, when the `ordered` field is `true`.
+   */
+  start?: number | null | undefined;
+  /**
+   * Whether one or more of the children are separated with a blank line from
+   * its siblings (when `true`), or not (when `false` or not present).
+   */
+  spread?: boolean | null | undefined;
+  /**
+   * Children of list.
+   */
+  children: ListContent[];
+  /**
+   * Data associated with the mdast list.
+   */
+  data?: ListData | undefined;
+}
+/**
+ * Info associated with mdast list nodes by the ecosystem.
+ */
+interface ListData extends Data {}
+/**
+ * Markdown list item.
+ */
+interface ListItem extends Parent {
+  /**
+   * Node type of mdast list item.
+   */
+  type: "listItem";
+  /**
+   * Whether the item is a tasklist item (when `boolean`).
+   *
+   * When `true`, the item is complete.
+   * When `false`, the item is incomplete.
+   */
+  checked?: boolean | null | undefined;
+  /**
+   * Whether one or more of the children are separated with a blank line from
+   * its siblings (when `true`), or not (when `false` or not present).
+   */
+  spread?: boolean | null | undefined;
+  /**
+   * Children of list item.
+   */
+  children: Array<BlockContent | DefinitionContent>;
+  /**
+   * Data associated with the mdast list item.
+   */
+  data?: ListItemData | undefined;
+}
+/**
+ * Info associated with mdast list item nodes by the ecosystem.
+ */
+interface ListItemData extends Data {}
+/**
+ * Markdown paragraph.
+ */
+interface Paragraph extends Parent {
+  /**
+   * Node type of mdast paragraph.
+   */
+  type: "paragraph";
+  /**
+   * Children of paragraph.
+   */
+  children: PhrasingContent[];
+  /**
+   * Data associated with the mdast paragraph.
+   */
+  data?: ParagraphData | undefined;
+}
+/**
+ * Info associated with mdast paragraph nodes by the ecosystem.
+ */
+interface ParagraphData extends Data {}
+/**
+ * Document fragment or a whole document.
+ *
+ * Should be used as the root of a tree and must not be used as a child.
+ */
+interface Root extends Parent {
+  /**
+   * Node type of mdast root.
+   */
+  type: "root";
+  /**
+   * Data associated with the mdast root.
+   */
+  data?: RootData | undefined;
+}
+/**
+ * Info associated with mdast root nodes by the ecosystem.
+ */
+interface RootData extends Data {}
+/**
+ * Markdown strong.
+ */
+interface Strong extends Parent {
+  /**
+   * Node type of mdast strong.
+   */
+  type: "strong";
+  /**
+   * Children of strong.
+   */
+  children: PhrasingContent[];
+  /**
+   * Data associated with the mdast strong.
+   */
+  data?: StrongData | undefined;
+}
+/**
+ * Info associated with mdast strong nodes by the ecosystem.
+ */
+interface StrongData extends Data {}
+/**
+ * Markdown GFM table.
+ */
+interface Table extends Parent {
+  /**
+   * Node type of mdast GFM table.
+   */
+  type: "table";
+  /**
+   * How cells in columns are aligned.
+   */
+  align?: AlignType[] | null | undefined;
+  /**
+   * Children of GFM table.
+   */
+  children: TableContent[];
+  /**
+   * Data associated with the mdast GFM table.
+   */
+  data?: TableData | undefined;
+}
+/**
+ * Info associated with mdast GFM table nodes by the ecosystem.
+ */
+interface TableData extends Data {}
+/**
+ * Markdown GFM table row.
+ */
+interface TableRow extends Parent {
+  /**
+   * Node type of mdast GFM table row.
+   */
+  type: "tableRow";
+  /**
+   * Children of GFM table row.
+   */
+  children: RowContent[];
+  /**
+   * Data associated with the mdast GFM table row.
+   */
+  data?: TableRowData | undefined;
+}
+/**
+ * Info associated with mdast GFM table row nodes by the ecosystem.
+ */
+interface TableRowData extends Data {}
+/**
+ * Markdown GFM table cell.
+ */
+interface TableCell extends Parent {
+  /**
+   * Node type of mdast GFM table cell.
+   */
+  type: "tableCell";
+  /**
+   * Children of GFM table cell.
+   */
+  children: PhrasingContent[];
+  /**
+   * Data associated with the mdast GFM table cell.
+   */
+  data?: TableCellData | undefined;
+}
+/**
+ * Info associated with mdast GFM table cell nodes by the ecosystem.
+ */
+interface TableCellData extends Data {}
+/**
+ * Markdown text.
+ */
+interface Text extends Literal {
+  /**
+   * Node type of mdast text.
+   */
+  type: "text";
+  /**
+   * Data associated with the mdast text.
+   */
+  data?: TextData | undefined;
+}
+/**
+ * Info associated with mdast text nodes by the ecosystem.
+ */
+interface TextData extends Data {}
+/**
+ * Markdown thematic break (horizontal rule).
+ */
+interface ThematicBreak extends Node$4 {
+  /**
+   * Node type of mdast thematic break.
+   */
+  type: "thematicBreak";
+  /**
+   * Data associated with the mdast thematic break.
+   */
+  data?: ThematicBreakData | undefined;
+}
+/**
+ * Info associated with mdast thematic break nodes by the ecosystem.
+ */
+interface ThematicBreakData extends Data {}
+/**
+ * Markdown YAML.
+ */
+interface Yaml extends Literal {
+  /**
+   * Node type of mdast YAML.
+   */
+  type: "yaml";
+  /**
+   * Data associated with the mdast YAML.
+   */
+  data?: YamlData | undefined;
+}
+/**
+ * Info associated with mdast YAML nodes by the ecosystem.
+ */
+interface YamlData extends Data {}
+//#endregion
+//#region src/types/common.d.ts
+type NodePath<T = t.Node | null | undefined> = NodePath$1<T>;
+type BabelAst = ParseResult;
+type PostcssAst = postcss.Root;
+interface MarkdownAst {
+  root: Root;
+  frontmatter: Record<string, string>;
+  render(): Promise<string>;
+}
+declare const CUSTOM_ATTRIBUTES: Readonly<{
+  /** For script and style tags to grab the metadata */MetadataID: "data-metadata-id";
+}>;
+declare const CONFIG_FILE_NAME = ".staticbolt.ts";
+interface AppConfig {
+  root?: string;
+  plugins?: (Plugin$1[] | Plugin$1)[];
+  outdir?: string;
+  production?: boolean;
+  browserslist?: string[];
+}
+//#endregion
+//#region src/resolver/resolver.d.ts
+type ResolveResult$1 = {
+  path: string;
+  suffix: string;
+  isDirAlias?: boolean;
+  isFileAlias?: boolean;
+  isPackage?: boolean;
+  exists: boolean;
+};
+declare class Resolver {
+  root: string;
+  aliases: Record<string, string>;
+  notFound: Set<string>;
+  files: Set<string>;
+  directories: Set<string>;
+  static JS_EXTENSIONS: Set<string>;
+  static HTML_EXTENSIONS: Set<string>;
+  constructor(root: string);
+  resolve(sourceOrLink: string, filePath: string): ResolveResult$1 | undefined;
+  resolveAlias(source: string): string | undefined;
+  normalize(filePath: string): string;
+  static isFile(filePath: string): boolean;
+  /** Aliased path to path */
+  static resolvePathAlias(filePath: string, aliases: Record<string, string>): string | undefined;
+  /** Path to aliased path */
+  static resolveAliasPath(filePath: string, aliases: Record<string, string>): string;
+  /** Path to aliased path */
+  aliasPath(filePath: string): string;
+  findFile(filePath: string, checkDirectory?: boolean): string | undefined;
+}
+//#endregion
+//#region src/main.d.ts
+declare class App {
+  readonly configPath: string;
+  /** The absolute path to the project root. */
+  readonly root: string;
+  /** The absolute path to the output directory. */
+  readonly outdir: string;
+  /** Whether the application is running in production mode. */
+  readonly production: boolean;
+  /** A list of browsers to target. */
+  readonly browserslist: string[];
+  readonly metadataList: MetadataBase$1[];
+  private readonly plugins;
+  readonly resolver: Resolver;
+  log: {
+    (...messages: unknown[]): void;
+    warn(...messages: string[]): void;
+    success(...messages: string[]): void;
+    error(...messages: string[]): void;
+    fatal(...messages: string[]): never;
+    info(...messages: string[]): void;
+    tip(...messages: string[]): void;
+    debug(...messages: string[]): void;
+    enableVerbose(enabled: boolean): void;
+    setVerboseFilter(filter: RegExp): void;
+  };
+  /** File paths to load as sources. */
+  readonly entryPoints: Set<string>;
+  /** Any type of data for plugins to use. */
+  readonly pluginData: Record<string, unknown>;
+  /** Exclude paths from being emitted. */
+  readonly emitExclude: Set<MetadataBase$1>;
+  /** Chokidar watcher. */
+  readonly watcher: FSWatcher | undefined;
+  private isPluginInitialized;
+  private measureExecutionTime;
+  private executionTime;
+  readonly pluginIndex: number;
+  readonly pluginName: string;
+  constructor(options: AppConfig$1 | undefined, configPath: string);
+  private bindPlugin;
+  private callPluginMethod;
+  private emitFileChange;
+  run(): Promise<void>;
+  process(id: string): Promise<void>;
+  resolve(metadata: MetadataBase$1): Promise<Set<string>>;
+  /**
+   * Resolve and load recursively
+   *
+   * 1. Resolves given metadata item or list
+   * 2. Loads discovered dependencies if not already loaded skipping entry points
+   * 3. Returns metadata list
+   */
+  resolveAndLoad(metadataItemOrList: MetadataBase$1 | MetadataBase$1[]): Promise<MetadataBase$1[]>;
+  transform(metadataItemOrList: MetadataBase$1 | MetadataBase$1[]): Promise<void>;
+  transformAndSync(metadataItemOrList: MetadataBase$1 | MetadataBase$1[]): Promise<void>;
+  rebase(metadata: MetadataBase$1, newAbsolutePath: string): Promise<void>;
+  writeFiles(metadataItemOrList: MetadataBase$1 | MetadataBase$1[]): Promise<void>;
+  read(filePath: string): Promise<string | undefined>;
+  load(relativePath: string, options?: {
+    code?: string;
+    type?: string;
+  }): Promise<MetadataBase$1 | undefined>;
+  requestSources(metadata: MetadataBase$1): Promise<MetadataSource$1[]>;
+  stringify(metadata: MetadataBase$1, options?: {
+    minify?: boolean;
+    format?: boolean;
+  }): Promise<string>;
+  getCompileList(event: "change" | "add" | "unlink", filePath: string): Promise<Set<string>>;
+  handleRequest(requestPath: string, reply: ServerReply$1, request: ServerRequest$1): Promise<true | undefined>;
+  resolveRequestPath(requestPath: string): Promise<string>;
+  clone<T extends MetadataBase$1>(metadata: T): T;
+  addMetadata(itemOrList: MetadataBase$1 | MetadataBase$1[]): void;
+  removeMetadata(metadataOrIndex: MetadataBase$1 | MetadataBase$1[] | number): void;
+  findMetadata<T extends MetadataBase$1>(metadataFilter: Partial<T>): T | undefined;
+  filterMetadata<T extends MetadataBase$1>(metadataFilter: Partial<T>): T[];
+}
+//#endregion
+//#region src/types/plugin.d.ts
+type FastifyHandlerParameters = Parameters<onRequestHookHandler>;
+type ServerReply = FastifyHandlerParameters[1];
+type ServerRequest = FastifyHandlerParameters[0];
+interface MetadataSource {
+  get source(): string;
+  set source(value: string);
+  node?: HTMLElement$1 | NodePath$1 | Postcss["AtRule"] | Postcss["Declaration"] | ImageResource | object;
+}
+interface ResolveResult {
+  source: string;
+  dependencyID?: string;
+}
+interface Plugin {
+  name: string;
+  setup?: (this: App$1) => void | Promise<void>;
+  read?: (this: App$1, absolutePath: string) => string | void | Promise<string | void>;
+  load?: (this: App$1, content: string, relativePath: string, options: {
+    type?: string;
+  }) => MetadataBase$1 | null | void | Promise<MetadataBase$1 | null | void>;
+  resolveSource?: (this: App$1, source: string, filePath: string, parentMetadata: MetadataBase$1) => ResolveResult | void | Promise<ResolveResult | void>;
+  transformSource?: (this: App$1, source: string, filePath: string, parentMetadata: MetadataBase$1) => string | void | Promise<string | void>;
+  preTransform?: (this: App$1) => void | Promise<void>;
+  transform?: (this: App$1, metadata: MetadataBase$1) => void | Promise<void>;
+  postTransform?: (this: App$1) => void | Promise<void>;
+  write?: (this: App$1, metadata: MetadataBase$1) => void | Promise<void>;
+  postBuild?: (this: App$1) => void | Promise<void>;
+  clone?: (this: App$1, metadata: MetadataBase$1) => void | MetadataBase$1;
+  stringify?: (this: App$1, metadata: MetadataBase$1, options: {
+    minify?: boolean;
+    format?: boolean;
+  }) => void | string | Promise<string | void>;
+  sourcesProvider?: (this: App$1, metadata: MetadataBase$1) => MetadataSource[] | void | Promise<MetadataSource[] | void>;
+  rebaseSource?: (this: App$1, source: string, filePath: string, newAbsolutePath: string) => string | void | Promise<string | void>;
+  onMetadataRebase?: (this: App$1, metadata: MetadataBase$1, oldAbsolutePath: string, newAbsolutePath: string) => void | Promise<void>;
+  handleRequest?: (this: App$1, requestPath: string, reply: ServerReply, request: ServerRequest) => boolean | void | Promise<boolean | void>;
+  resolveRequestPath?: (this: App$1, requestPath: string) => string | void | Promise<string | void>;
+  onFileEvent?: (this: App$1, event: "change" | "add" | "unlink", filePath: string) => void | Promise<void>;
+  resolveCompileList?: (this: App$1, compileSet: Set<string>, event: "change" | "add" | "unlink", filePath: string) => void | Promise<void>;
+  cli?: (this: CliProgram$1, config: AppConfig$1, configPath: string) => void | Promise<void>;
+}
+type RemoveThis<T> = Required<{ [K in keyof T]: T[K] extends ((this: App$1, ...arguments_: infer A) => infer R) | undefined ? (...arguments_: A) => R : T[K] }>;
+type BoundPlugin = RemoveThis<Plugin>;
+//#endregion
+//#region src/types/metadata.d.ts
+declare const METADATA_TYPES: Readonly<{
+  Script: "Script";
+  HTML: "Html";
+  Markdown: "Markdown";
+  CSS: "Style";
+  SVG: "Svg";
+  Package: "Package";
+  TextAsset: "TextAsset";
+  BinaryAsset: "BinaryAsset";
+  WebAppManifest: "WebAppManifest";
+}>;
+type MetadataTypes = (typeof METADATA_TYPES)[keyof typeof METADATA_TYPES];
+interface MetadataBase {
+  readonly type: `${Capitalize<string>}${string}`;
+  /**
+   * Relative path of the source file.
+   *
+   * Initially identical to `originalSource` when the metadata is created. During the build process, this value may change (e.g.,
+   * if the file is moved to a different location and its links are rebased).
+   */
+  filePath: string;
+  /**
+   * Original relative path of the source file.
+   *
+   * Set when the metadata is created and never modified.
+   */
+  readonly id: string;
+  readonly directDependencies: Set<string>;
+}
+interface ScriptMetadata extends MetadataBase {
+  readonly type: (typeof METADATA_TYPES)["Script"];
+  /**
+   * The Babel AST for the script.
+   *
+   * Mutated during the build process and always represents the file's current transformed state.
+   */
+  ast: BabelAst$1;
+  /** Whether the script is a module or global */
+  module: boolean;
+}
+interface StyleMetadata extends MetadataBase {
+  readonly type: (typeof METADATA_TYPES)["CSS"];
+  /**
+   * The PostCSS root after transformation
+   *
+   * Mutated during the build process and always represents the file's current transformed state.
+   */
+  ast: PostcssAst$1;
+}
+interface HtmlMetadata extends MetadataBase {
+  type: (typeof METADATA_TYPES)["HTML"];
+  /**
+   * The HTML AST (root element).
+   *
+   * Mutated during the build process and always represents the file's current transformed state
+   */
+  ast: Document$1;
+  /** The transformed ASTs from script tags. The key is the UUID */
+  scriptsMetadataList: Map<string, ScriptMetadata>;
+  /** The transformed ASTs from script tags. The key is the UUID */
+  stylesMetadataList: Map<string, StyleMetadata>;
+}
+interface SvgMetadata extends MetadataBase {
+  type: (typeof METADATA_TYPES)["SVG"];
+  /**
+   * The HTML AST (root element).
+   *
+   * Mutated during the build process and always represents the file's current transformed state
+   */
+  ast: Document$1;
+  /** The transformed ASTs from script tags. The key is the UUID */
+  stylesMetadataList: Map<string, StyleMetadata>;
+}
+interface MarkdownMetadata extends MetadataBase {
+  type: (typeof METADATA_TYPES)["Markdown"];
+  /**
+   * Markdown tokens and frontmatter.
+   *
+   * Mutated during the build process and always represents the file's current transformed state
+   */
+  ast: MarkdownAst$1;
+}
+interface WebManifestMetadata extends MetadataBase {
+  type: (typeof METADATA_TYPES)["WebAppManifest"];
+  ast: WebAppManifest;
+}
+interface PackageMetadata extends MetadataBase {
+  type: (typeof METADATA_TYPES)["Package"];
+  /** Metadata code */
+  code: string;
+  packageName: string;
+}
+interface TextAssetMetadata extends MetadataBase {
+  type: (typeof METADATA_TYPES)["TextAsset"];
+  /** Metadata code */
+  code: string;
+}
+interface BinaryAssetMetadata extends MetadataBase {
+  type: (typeof METADATA_TYPES)["BinaryAsset"];
+  /** Raw binary content — images, fonts, wasm, etc. */
+  data?: Uint8Array;
+}
+//#endregion
+//#region src/cli/cli.d.ts
+declare class CliProgram {
+  #private;
+  program: {
+    cliName: "staticbolt";
+    meta: {
+      description: string;
+      example: string;
+    };
+    options: {
+      help: {
+        aliases: string[];
+        schema: z.ZodOptional<z.ZodBoolean>;
+        coerce: {
+          <T extends boolean | undefined>(terminalInput: string): T;
+          type: string;
+        };
+        meta: {
+          description: string;
+        };
+      };
+      version: {
+        aliases: string[];
+        schema: z.ZodOptional<z.ZodBoolean>;
+        coerce: {
+          <T extends boolean | undefined>(terminalInput: string): T;
+          type: string;
+        };
+        meta: {
+          description: string;
+        };
+      };
+    };
+    onExecute: (handler: (data: {
+      subcommand: undefined;
+      options: {
+        help?: boolean | undefined;
+        version?: boolean | undefined;
+      };
+      arguments: never;
+      positionals: never;
+      context: {
+        subcommand: undefined;
+        options: {
+          help: _$_staticbolt_args_parser0.OptionContext<z.ZodOptional<z.ZodBoolean>>;
+          version: _$_staticbolt_args_parser0.OptionContext<z.ZodOptional<z.ZodBoolean>>;
+        };
+        arguments: never;
+        positionals: never;
+      };
+    }) => void) => () => void;
+    execute: (input?: {
+      options?: {
+        help?: boolean | undefined;
+        version?: boolean | undefined;
+      } | undefined;
+      arguments?: undefined;
+      positionals?: undefined;
+    } | undefined) => void;
+    executeAsync: (input?: {
+      options?: {
+        help?: boolean | undefined;
+        version?: boolean | undefined;
+      } | undefined;
+      arguments?: undefined;
+      positionals?: undefined;
+    } | undefined) => Promise<void>;
+    generateCliHelpMessage?: ((options?: _$_staticbolt_args_parser0.PrintHelpOptions) => string) | undefined;
+    generateSubcommandHelpMessage?: ((subcommandName: string & {}, options?: _$_staticbolt_args_parser0.PrintHelpOptions) => string) | undefined;
+    run: (input: string | string[]) => _$_staticbolt_args_parser0.CliParseResult<{
+      cliName: "staticbolt";
+      meta: {
+        description: string;
+        example: string;
+      };
+      options: {
+        help: {
+          aliases: string[];
+          schema: z.ZodOptional<z.ZodBoolean>;
+          coerce: {
+            <T extends boolean | undefined>(terminalInput: string): T;
+            type: string;
+          };
+          meta: {
+            description: string;
+          };
+        };
+        version: {
+          aliases: string[];
+          schema: z.ZodOptional<z.ZodBoolean>;
+          coerce: {
+            <T extends boolean | undefined>(terminalInput: string): T;
+            type: string;
+          };
+          meta: {
+            description: string;
+          };
+        };
+      };
+    }>;
+    runAsync: (input: string | string[]) => Promise<_$_staticbolt_args_parser0.CliParseResult<{
+      cliName: "staticbolt";
+      meta: {
+        description: string;
+        example: string;
+      };
+      options: {
+        help: {
+          aliases: string[];
+          schema: z.ZodOptional<z.ZodBoolean>;
+          coerce: {
+            <T extends boolean | undefined>(terminalInput: string): T;
+            type: string;
+          };
+          meta: {
+            description: string;
+          };
+        };
+        version: {
+          aliases: string[];
+          schema: z.ZodOptional<z.ZodBoolean>;
+          coerce: {
+            <T extends boolean | undefined>(terminalInput: string): T;
+            type: string;
+          };
+          meta: {
+            description: string;
+          };
+        };
+      };
+    }>>;
+  };
+  constructor();
+  initializePlugins(config: AppConfig$1, configPath: string): Promise<void>;
+  static init(config: AppConfig$1, configPath: string): Promise<CliProgram>;
+  run(cliArguments: string[]): _$_staticbolt_args_parser0.CliParseResult<{
+    cliName: "staticbolt";
+    meta: {
+      description: string;
+      example: string;
+    };
+    options: {
+      help: {
+        aliases: string[];
+        schema: z.ZodOptional<z.ZodBoolean>;
+        coerce: {
+          <T extends boolean | undefined>(terminalInput: string): T;
+          type: string;
+        };
+        meta: {
+          description: string;
+        };
+      };
+      version: {
+        aliases: string[];
+        schema: z.ZodOptional<z.ZodBoolean>;
+        coerce: {
+          <T extends boolean | undefined>(terminalInput: string): T;
+          type: string;
+        };
+        meta: {
+          description: string;
+        };
+      };
+    };
+  }>;
+  readonly defineSubcommand: typeof defineSubcommand;
+  readonly defineOptions: typeof defineOptions;
+  readonly defineArguments: typeof defineArguments;
+  readonly coerce: {
+    string: <T extends string | undefined>(terminalInput: string) => T;
+    boolean: {
+      <T extends boolean | undefined>(terminalInput: string): T;
+      type: string;
+    };
+    number: <T extends number | undefined>(terminalInput: string) => T;
+    bigint: <T extends bigint | undefined>(terminalInput: string) => T;
+    object: (options?: _$_staticbolt_args_parser0.ObjectCoerceMethodOptions) => <T extends Record<string, unknown> | undefined>(terminalInput: string) => T;
+    stringArray: (separator: string) => <T extends string[] | undefined>(terminalInput: string) => T;
+    numberArray: (separator: string) => <T extends number[] | undefined>(terminalInput: string) => T;
+    booleanArray: (separator: string) => <T extends boolean[] | undefined>(terminalInput: string) => T;
+    stringSet: (separator: string) => <T extends Set<string> | undefined>(terminalInput: string) => T;
+    numberSet: (separator: string) => <T extends Set<number> | undefined>(terminalInput: string) => T;
+    booleanSet: (separator: string) => <T extends Set<boolean> | undefined>(terminalInput: string) => T;
+    json: <T>(terminalInput: string) => T;
+  };
+  addCommand(newSubcommand: Subcommand): number | undefined;
+  addOptions(newOptions: Record<string, Option>): (Record<string, Option<_$_staticbolt_args_parser0.SchemaType<unknown>>> & Record<string, Option>) | undefined;
+  addArguments(newArguments: Record<string, Argument>): (Record<string, Argument<_$_staticbolt_args_parser0.SchemaType<unknown>>> & Record<string, Argument>) | undefined;
+  addOptionsToCommand(commandName: string, newOptions: Record<string, Option>): (Record<string, Option<_$_staticbolt_args_parser0.SchemaType<unknown>>> & Record<string, Option>) | undefined;
+  addArgumentsToCommand(commandName: string, newArguments: Record<string, Argument>): (Record<string, Argument<_$_staticbolt_args_parser0.SchemaType<unknown>>> & Record<string, Argument>) | undefined;
+}
+//#endregion
+//#region src/utilities/path.d.ts
+declare const join: (...arguments_: string[]) => string;
+declare const relative: (from: string, to: string) => string;
+declare const dirname: (path: string) => string;
+declare const normalize: (path: string) => string;
+/**
+ * Recalculates the relative path for a resource after a file has been moved.
+ *
+ * @param source - The source found in the `oldPath` file.
+ * @param oldPath - Absolute or relative original path of the file.
+ * @param newPath - Absolute or relative new path of the file.
+ * @returns The updated relative path from the new file's directory to the same resource.
+ */
+declare function rebaseRelativePath(source: string, oldPath: string, newPath: string): string;
+/**
+ * Checks if a path (child) is a subpath of another (parent).
+ *
+ * Note: both paths must be of the same type — either both absolute or both relative. Mixing them will produce incorrect results.
+ *
+ * @param parentDirectory - The parent directory.
+ * @param childPath - The child path (file or directory).
+ */
+declare function isSubpath(parentDirectory: string, childPath: string): boolean;
+interface SourceRelativeToRootOptions {
+  /** The root directory (absolute or resolvable) */
+  root: string;
+  /** The file path that contains the source path */
+  filePath: string;
+  /** The source path */
+  sourcePath: string;
+}
+/** Calculates the relative path of a source path to the root. */
+declare function sourceRelativeToRoot({
+  root,
+  filePath,
+  sourcePath
+}: SourceRelativeToRootOptions): string;
+/** Replaces the extension of a given path. */
+declare function replaceExtension(filePath: string, extension: string): string;
+/** Appends a forward slash to the end of a path if it doesn't already end with one. */
+declare const appendForwardSlash: (path: string) => string;
+/** Removes the leading `./` from a path. */
+declare const trimDotPrefix: (path: string) => string;
+/** Returns the first segment of a path. */
+declare function firstPart(path: string): string;
+interface MatchPathOptions {
+  include: string | string[];
+  ignore?: string | string[];
+  root: string;
+}
+/** Checks if a file path matches a set of patterns. */
+declare function matchPath(filePath: string, {
+  include,
+  ignore,
+  root
+}: MatchPathOptions): boolean;
+//#endregion
+//#region src/utilities/metadata-utilities.d.ts
+declare function isScriptMetadata(metadata: MetadataBase$1 | undefined): metadata is ScriptMetadata$1;
+declare function isPackageMetadata(metadata: MetadataBase$1 | undefined): metadata is PackageMetadata$1;
+declare function isHtmlMetadata(metadata: MetadataBase$1 | undefined): metadata is HtmlMetadata$1;
+declare function isStyleMetadata(metadata: MetadataBase$1 | undefined): metadata is StyleMetadata$1;
+declare function isSvgMetadata(metadata: MetadataBase$1 | undefined): metadata is SvgMetadata$1;
+declare function isMarkdownMetadata(metadata: MetadataBase$1 | undefined): metadata is MarkdownMetadata$1;
+declare function isTextAssetMetadata(metadata: MetadataBase$1 | undefined): metadata is TextAssetMetadata$1;
+declare function isBinaryAssetMetadata(metadata: MetadataBase$1 | undefined): metadata is BinaryAssetMetadata$1;
+declare function isWebManifestMetadata(metadata: MetadataBase$1): metadata is WebManifestMetadata$1;
+/**
+ * Returns script-related metadata entries.
+ *
+ * - If the input is ScriptMetadata, it returns it directly.
+ * - If the input is HtmlMetadata, it scans <script> tags in the AST and resolves their associated ScriptMetadata using the metadata
+ *   ID attribute.
+ */
+declare function filterScriptMetadata(metadata: MetadataBase$1): {
+  metadata: ScriptMetadata$1;
+  tag?: HTMLElement$2;
+  htmlMetadata?: HtmlMetadata$1;
+}[];
+/**
+ * Returns style-related metadata entries.
+ *
+ * - If the input is StyleMetadata, it returns it directly.
+ * - If the input is HtmlMetadata, it scans <style> tags in the AST and resolves their associated StyleMetadata using the metadata
+ *   ID attribute.
+ */
+declare function filterStyleMetadata(metadata: MetadataBase$1): {
+  metadata: StyleMetadata$1;
+  tag?: HTMLElement$2;
+  htmlMetadata?: HtmlMetadata$1;
+}[];
+//#endregion
+//#region src/utilities/print-formatted-error.d.ts
+type Node$3 = Node$2 | Node$1 | Node;
+interface FormatErrorOptions {
+  /** AST node (e.g., from Babel, PostCSS, or HTML) to convert and highlight */
+  node?: Node$3;
+  /** Source code to highlight (use instead of `node`) */
+  code?: string;
+  /** Language of the provided source code (required if `code` is set) */
+  lang?: string;
+  /** Path of the file where the error occurred */
+  filePath?: string;
+  /** Name of the function where the error originated */
+  functionName?: string;
+  level?: "error" | "warning";
+  /** Function reference used to extract the function name */
+  function?: (...arguments_: any[]) => any;
+}
+type MessageAndError = (string | Error)[];
+declare class PrintFormattedError {
+  options: FormatErrorOptions;
+  constructor(options?: FormatErrorOptions);
+  static create(options?: FormatErrorOptions): (...messageAndErrorWithOptions: [...MessageAndError] | [...MessageAndError, FormatErrorOptions]) => void;
+  print: (...messageAndErrorWithOptions: [...MessageAndError] | [...MessageAndError, FormatErrorOptions]) => void;
+}
+declare const printFmtError: (...messageAndErrorWithOptions: [...MessageAndError] | [...MessageAndError, FormatErrorOptions]) => void;
+//#endregion
+//#region src/utilities/value-or-error.d.ts
+type ValueOrError<T> = [T, null] | [null, Error];
+//#endregion
+//#region src/utilities/read-file.d.ts
+declare function safeReadFile(path: PathLike | FileHandle, options?: ({
+  encoding?: null | undefined;
+  flag?: OpenMode | undefined;
+} & Abortable) | null): Promise<ValueOrError<Buffer>>;
+declare function safeReadFile(path: PathLike | FileHandle, options: ({
+  encoding: BufferEncoding;
+  flag?: OpenMode | undefined;
+} & Abortable) | BufferEncoding): Promise<ValueOrError<string>>;
+declare function safeReadFile(path: PathLike | FileHandle, options?: (ObjectEncodingOptions & Abortable & {
+  flag?: OpenMode | undefined;
+}) | BufferEncoding | null): Promise<ValueOrError<string | Buffer>>;
+declare function safeReadFileSync(path: PathOrFileDescriptor, options?: {
+  encoding?: null | undefined;
+  flag?: string | undefined;
+} | null): ValueOrError<NonSharedBuffer>;
+declare function safeReadFileSync(path: PathOrFileDescriptor, options: {
+  encoding: BufferEncoding;
+  flag?: string | undefined;
+} | BufferEncoding): ValueOrError<string>;
+declare function safeReadFileSync(path: PathOrFileDescriptor, options?: (ObjectEncodingOptions & {
+  flag?: string | undefined;
+}) | BufferEncoding | null): ValueOrError<string | NonSharedBuffer>;
+//#endregion
+//#region src/utilities/utilities.d.ts
+/** `process.stdout.write` */
+declare function print(...input: string[]): void;
+/** - Clear the line in the terminal */
+declare function clearLn(): void;
+/** Used to assign a computed value to a variable */
+declare function assign<T>(function_: () => T): T;
+/** Check if the value is an object */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+declare function kebabToCamelCase(string_: string): string;
+declare function camelCaseToKebabCase(string_: string): string;
+declare function capitalize(string_: string): string;
+/**
+ * - Get line and column number from first match index
+ *
+ * @param code - Code string
+ * @param matchIndex - Matching index
+ * @returns - `[line, column]`
+ */
+declare function getLineColumn(code: string, matchIndex: number): [number, number];
+/** - Human readable bytes, E.g: `1024 => 1KB` */
+declare function humanReadableBytes(bytes: number): string;
+declare function bytesToKB(bytes: number): number;
+/** - Clamp a numeric value between min and max values. */
+declare function clamp(value: number, min: number, max: number): number;
+declare function isDefined<T>(value: T | undefined): value is T;
+/**
+ * Merges all entries from `source` into `target`, mutating `target` in place.
+ *
+ * - Existing keys in `target` are overwritten by `source` values.
+ * - Values are **not** cloned — object references are shared between both maps after the merge.
+ *
+ * @param target - The map to be mutated with new/updated entries.
+ * @param source - The map whose entries are read and applied to `target`.
+ * @returns The mutated `target` map.
+ */
+declare function mergeMaps<K, V>(target: Map<K, V>, source: Map<K, V>): Map<K, V>;
+/** - Download from CDN */
+declare function downloadContent(url: string): Promise<ValueOrError<string>>;
+declare function isURL(url: string): boolean;
+/** Creates a shallow clone of an object while preserving its prototype and property descriptors. */
+declare function cloneObject<T extends object>(object: T): T;
+declare function hashContent(content: string): string;
+declare function escapeHtml(input: string): string;
+//#endregion
+//#region src/helpers/dependency-tracker.d.ts
+/**
+ * Tracks bidirectional dependencies between importers and their sources.\
+ * Handles reconciliation when dependencies change, so stale entries are automatically removed when an importer stops referencing
+ * a source.
+ */
+declare class DependencyTracker {
+  #private;
+  /** Updates the full set of sources for a given importer, reconciling any stale entries from previous calls. */
+  update(importer: string, sources: Iterable<string>): void;
+  /** Deletes all dependency data for a given id, whether it's acting as an importer, a source, or both (e.g. on file unlink). */
+  delete(id: string): void;
+  /** Returns all importers that depend on a given source, or an empty set. */
+  getImporters(source: string): ReadonlySet<string>;
+  /** Returns all sources that a given importer depends on, or an empty set. */
+  getSources(importer: string): ReadonlySet<string>;
+}
+//#endregion
+//#region src/index.d.ts
+declare function defineConfig(config: AppConfig): AppConfig;
+//#endregion
+export { type App, AppConfig, BabelAst, BinaryAssetMetadata, BoundPlugin, CONFIG_FILE_NAME, CUSTOM_ATTRIBUTES, CliProgram, DependencyTracker, type Document, type HTMLElement, HtmlMetadata, METADATA_TYPES, MarkdownAst, MarkdownMetadata, MetadataBase, MetadataSource, MetadataTypes, NodePath, PackageMetadata, Plugin, PostcssAst, PrintFormattedError, ResolveResult, ScriptMetadata, ServerReply, ServerRequest, StyleMetadata, SvgMetadata, TextAssetMetadata, WebManifestMetadata, appendForwardSlash, assign, basename, bytesToKB, camelCaseToKebabCase, capitalize, clamp, clearLn, cloneObject, defineConfig, dirname, downloadContent, escapeHtml, extname, filterScriptMetadata, filterStyleMetadata, firstPart, getLineColumn, hashContent, humanReadableBytes, isAbsolute, isBinaryAssetMetadata, isDefined, isHtmlMetadata, isMarkdownMetadata, isObject, isPackageMetadata, isScriptMetadata, isStyleMetadata, isSubpath, isSvgMetadata, isTextAssetMetadata, isURL, isWebManifestMetadata, join, kebabToCamelCase, matchPath, mergeMaps, normalize, parse, print, printFmtError, rebaseRelativePath, relative, replaceExtension, resolve, safeReadFile, safeReadFileSync, sourceRelativeToRoot, trimDotPrefix };
+//# sourceMappingURL=index.d.mts.map