@astryx-vue/core 0.3.0 → 0.4.1

package/dist/protocol-DwUmpC5G.d.ts

@@ -0,0 +1,240 @@
+//#region src/Markdown/canonicalAst.d.ts
+type MarkdownAstDataValue = null | boolean | number | string | readonly MarkdownAstDataValue[] | {
+  readonly [key: string]: MarkdownAstDataValue;
+};
+interface MarkdownAstPoint {
+  readonly line?: number;
+  readonly column?: number;
+  readonly offset?: number;
+}
+interface MarkdownAstPosition {
+  readonly start: MarkdownAstPoint;
+  readonly end: MarkdownAstPoint;
+}
+interface MarkdownAstNodeBase {
+  readonly position?: MarkdownAstPosition;
+  readonly data?: MarkdownAstDataValue;
+}
+interface MarkdownAstExtensionNode<Plugin extends string = string, Name extends string = string, Data extends MarkdownAstDataValue = MarkdownAstDataValue, Display extends 'inline' | 'block' = 'inline' | 'block'> extends MarkdownAstNodeBase {
+  readonly type: 'extension';
+  readonly plugin: Plugin;
+  readonly name: Name;
+  readonly data: Data;
+  readonly display: Display;
+  readonly source?: string;
+}
+interface MarkdownAstText extends MarkdownAstNodeBase {
+  readonly type: 'text';
+  readonly value: string;
+}
+interface MarkdownAstParent<Type extends 'strong' | 'emphasis' | 'delete', Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: Type;
+  readonly children: readonly MarkdownAstPhrasingContent<Extension>[];
+}
+interface MarkdownAstInlineCode extends MarkdownAstNodeBase {
+  readonly type: 'inlineCode';
+  readonly value: string;
+}
+interface MarkdownAstInlineMath extends MarkdownAstNodeBase {
+  readonly type: 'inlineMath';
+  readonly value: string;
+}
+interface MarkdownAstLink<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'link';
+  readonly url: string;
+  readonly children: readonly MarkdownAstPhrasingContent<Extension>[];
+}
+interface MarkdownAstImage extends MarkdownAstNodeBase {
+  readonly type: 'image';
+  readonly url: string;
+  readonly alt: string;
+}
+interface MarkdownAstCitation extends MarkdownAstNodeBase {
+  readonly type: 'citation';
+  readonly sourceId: string;
+}
+interface MarkdownAstBreak extends MarkdownAstNodeBase {
+  readonly type: 'break';
+}
+type MarkdownAstPhrasingContent<Extension extends MarkdownAstExtensionNode = never> = MarkdownAstText | MarkdownAstParent<'strong', Extension> | MarkdownAstParent<'emphasis', Extension> | MarkdownAstParent<'delete', Extension> | MarkdownAstInlineCode | MarkdownAstInlineMath | MarkdownAstLink<Extension> | MarkdownAstImage | MarkdownAstCitation | MarkdownAstBreak | (Extension & {
+  readonly display: 'inline';
+});
+interface MarkdownAstHeading<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'heading';
+  readonly depth: 1 | 2 | 3 | 4 | 5 | 6;
+  readonly children: readonly MarkdownAstPhrasingContent<Extension>[];
+}
+interface MarkdownAstParagraph<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'paragraph';
+  readonly children: readonly MarkdownAstPhrasingContent<Extension>[];
+}
+interface MarkdownAstCode extends MarkdownAstNodeBase {
+  readonly type: 'code';
+  readonly lang: string | null;
+  readonly meta?: string;
+  readonly value: string;
+}
+interface MarkdownAstMath extends MarkdownAstNodeBase {
+  readonly type: 'math';
+  readonly value: string;
+}
+interface MarkdownAstBlockquote<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'blockquote';
+  readonly children: readonly MarkdownAstBlockContent<Extension>[];
+}
+interface MarkdownAstListItem<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'listItem';
+  readonly checked?: boolean;
+  readonly children: readonly MarkdownAstBlockContent<Extension>[];
+}
+interface MarkdownAstList<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'list';
+  readonly ordered: boolean;
+  readonly start?: number;
+  readonly spread?: boolean;
+  readonly delimiter?: '.' | ')';
+  readonly children: readonly MarkdownAstListItem<Extension>[];
+}
+type MarkdownAstTableAlignment = 'left' | 'center' | 'right' | null;
+interface MarkdownAstTableCell<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'tableCell';
+  readonly children: readonly MarkdownAstPhrasingContent<Extension>[];
+}
+interface MarkdownAstTableRow<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'tableRow';
+  readonly children: readonly MarkdownAstTableCell<Extension>[];
+}
+interface MarkdownAstTable<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'table';
+  readonly align: readonly MarkdownAstTableAlignment[];
+  readonly children: readonly MarkdownAstTableRow<Extension>[];
+}
+interface MarkdownAstThematicBreak extends MarkdownAstNodeBase {
+  readonly type: 'thematicBreak';
+}
+type MarkdownAstBlockContent<Extension extends MarkdownAstExtensionNode = never> = MarkdownAstHeading<Extension> | MarkdownAstParagraph<Extension> | MarkdownAstCode | MarkdownAstMath | MarkdownAstBlockquote<Extension> | MarkdownAstList<Extension> | MarkdownAstTable<Extension> | MarkdownAstThematicBreak | MarkdownAstImage | (Extension & {
+  readonly display: 'block';
+});
+interface MarkdownAstRoot<Extension extends MarkdownAstExtensionNode = never> extends MarkdownAstNodeBase {
+  readonly type: 'root';
+  readonly children: readonly MarkdownAstBlockContent<Extension>[];
+}
+interface MarkdownAstNodeMap<Extension extends MarkdownAstExtensionNode = MarkdownAstExtensionNode> {
+  readonly root: MarkdownAstRoot<Extension>;
+  readonly text: MarkdownAstText;
+  readonly strong: MarkdownAstParent<'strong', Extension>;
+  readonly emphasis: MarkdownAstParent<'emphasis', Extension>;
+  readonly delete: MarkdownAstParent<'delete', Extension>;
+  readonly inlineCode: MarkdownAstInlineCode;
+  readonly inlineMath: MarkdownAstInlineMath;
+  readonly break: MarkdownAstBreak;
+  readonly link: MarkdownAstLink<Extension>;
+  readonly image: MarkdownAstImage;
+  readonly citation: MarkdownAstCitation;
+  readonly heading: MarkdownAstHeading<Extension>;
+  readonly paragraph: MarkdownAstParagraph<Extension>;
+  readonly code: MarkdownAstCode;
+  readonly math: MarkdownAstMath;
+  readonly blockquote: MarkdownAstBlockquote<Extension>;
+  readonly list: MarkdownAstList<Extension>;
+  readonly listItem: MarkdownAstListItem<Extension>;
+  readonly table: MarkdownAstTable<Extension>;
+  readonly tableRow: MarkdownAstTableRow<Extension>;
+  readonly tableCell: MarkdownAstTableCell<Extension>;
+  readonly thematicBreak: MarkdownAstThematicBreak;
+  readonly extension: Extension;
+}
+type MarkdownAstNode<Extension extends MarkdownAstExtensionNode = MarkdownAstExtensionNode, Type extends keyof MarkdownAstNodeMap<Extension> = keyof MarkdownAstNodeMap<Extension>> = MarkdownAstNodeMap<Extension>[Type];
+declare function visitMarkdownNodes<Extension extends MarkdownAstExtensionNode, Type extends keyof MarkdownAstNodeMap<Extension>>(root: MarkdownAstRoot<Extension>, type: Type, visitor: (node: MarkdownAstNodeMap<Extension>[Type]) => void): void;
+//#endregion
+//#region src/Markdown/plugin-protocol/protocol.d.ts
+type MarkdownPluginData = MarkdownAstDataValue;
+type MarkdownExtensionNode<PluginName extends string = string, NodeName extends string = string, Data extends MarkdownPluginData = MarkdownPluginData, Display extends 'inline' | 'block' = 'inline' | 'block'> = MarkdownAstExtensionNode<PluginName, NodeName, Data, Display>;
+declare function isMarkdownExtensionNode<Node extends MarkdownExtensionNode>(node: {
+  readonly type: string;
+}, plugin: Node['plugin'], name: Node['name']): node is Node;
+interface MarkdownTokenizerInput {
+  readonly source: string;
+  readonly offset: number;
+  readonly end: number;
+  readonly isFinal: boolean;
+  readonly context: 'inline' | 'block';
+  readonly lineStart: number;
+  readonly column: number;
+}
+type MarkdownTokenizeResult<Node extends MarkdownExtensionNode> = {
+  readonly status: 'no-match';
+} | {
+  readonly status: 'defer';
+} | {
+  readonly status: 'match';
+  readonly end: number;
+  readonly node: Omit<Node, 'source' | 'position'>;
+};
+interface MarkdownSyntaxContribution<Node extends MarkdownExtensionNode = MarkdownExtensionNode> {
+  readonly startsWith: readonly [string, ...string[]];
+  readonly maxSpan: number;
+  tokenize: (input: MarkdownTokenizerInput) => MarkdownTokenizeResult<Node>;
+}
+interface MarkdownSyntaxCapability<Node extends MarkdownExtensionNode = MarkdownExtensionNode> {
+  readonly inline?: readonly MarkdownSyntaxContribution<Node>[];
+  readonly block?: readonly MarkdownSyntaxContribution<Node>[];
+}
+interface MarkdownTransformContext {
+  readonly source: string;
+  readonly isFinal: boolean;
+  readonly display: 'inline' | 'block';
+  report: (message: string) => void;
+}
+declare const markdownTransformNode: unique symbol;
+interface MarkdownTransform<Node extends MarkdownExtensionNode = never> {
+  (document: MarkdownAstRoot<MarkdownExtensionNode>, context: MarkdownTransformContext): MarkdownAstRoot<MarkdownExtensionNode>;
+  readonly [markdownTransformNode]?: Node;
+}
+interface MarkdownExtensionRenderer<Node extends MarkdownExtensionNode> {
+  readonly render: (props: {
+    node: Node;
+  }) => unknown;
+  readonly toText: (node: Node) => string;
+}
+type MarkdownExtensionRenderers<Node extends MarkdownExtensionNode> = Readonly<{ [NodeName in Node['name']]: MarkdownExtensionRenderer<Extract<Node, {
+  name: NodeName;
+}>>; }>;
+interface MarkdownPluginDefinitionBase<Name extends string> {
+  readonly name: Name;
+  readonly apiVersion: 1;
+}
+interface MarkdownSyntaxPluginDefinition<Name extends string, Node extends MarkdownExtensionNode<Name>> extends MarkdownPluginDefinitionBase<Name> {
+  readonly parseKey: string;
+  readonly syntax: MarkdownSyntaxCapability<Node>;
+  readonly transform?: MarkdownTransform<Node>;
+  readonly renderers: MarkdownExtensionRenderers<Node>;
+}
+type MarkdownTransformPluginDefinition<Name extends string, Node extends MarkdownExtensionNode<Name> = never> = MarkdownPluginDefinitionBase<Name> & {
+  readonly transform: MarkdownTransform<Node>;
+  readonly parseKey?: never;
+  readonly syntax?: never;
+  readonly renderers?: MarkdownExtensionRenderers<Node>;
+};
+type MarkdownPluginDefinition<Name extends string, Node extends MarkdownExtensionNode<Name> = never> = MarkdownSyntaxPluginDefinition<Name, Node> | MarkdownTransformPluginDefinition<Name, Node>;
+declare const markdownPluginNode: unique symbol;
+interface MarkdownPluginEntry<Node extends MarkdownExtensionNode = MarkdownExtensionNode> {
+  readonly name: string;
+  readonly apiVersion: 1;
+  readonly [markdownPluginNode]: Node;
+}
+type MarkdownNodeOf<Entry> = Entry extends MarkdownPluginEntry<infer Node> ? Node : never;
+type MarkdownExtensionsOf<Plugins extends readonly MarkdownPluginEntry[]> = MarkdownNodeOf<Plugins[number]>;
+interface MarkdownPluginCapabilities {
+  readonly syntax: boolean;
+  readonly transform: boolean;
+}
+declare function isMarkdownPluginData(value: unknown, seen?: Set<object>): value is MarkdownPluginData;
+declare function getMarkdownPluginCapabilities(plugin: MarkdownPluginEntry): MarkdownPluginCapabilities;
+declare function createMarkdownPlugin<const Name extends string, const Node extends MarkdownExtensionNode<Name>>(definition: MarkdownSyntaxPluginDefinition<Name, Node>): MarkdownPluginEntry<Node>;
+declare function createMarkdownPlugin<const Name extends string>(definition: MarkdownTransformPluginDefinition<Name, never>): MarkdownPluginEntry<never>;
+declare function createMarkdownPlugin<const Name extends string, const Node extends MarkdownExtensionNode<Name>>(definition: MarkdownTransformPluginDefinition<Name, Node>): MarkdownPluginEntry<Node>;
+declare function isMarkdownPluginEntry(value: unknown): value is MarkdownPluginEntry;
+declare function isMarkdownSourceLinesPlugin(plugin: MarkdownPluginEntry): boolean;
+//#endregion
+export { MarkdownAstExtensionNode as A, MarkdownAstNodeBase as B, isMarkdownSourceLinesPlugin as C, MarkdownAstCitation as D, MarkdownAstBreak as E, MarkdownAstLink as F, MarkdownAstPosition as G, MarkdownAstParagraph as H, MarkdownAstList as I, MarkdownAstTableCell as J, MarkdownAstRoot as K, MarkdownAstListItem as L, MarkdownAstImage as M, MarkdownAstInlineCode as N, MarkdownAstCode as O, MarkdownAstInlineMath as P, visitMarkdownNodes as Q, MarkdownAstMath as R, isMarkdownPluginEntry as S, MarkdownAstBlockquote as T, MarkdownAstPhrasingContent as U, MarkdownAstNodeMap as V, MarkdownAstPoint as W, MarkdownAstText as X, MarkdownAstTableRow as Y, MarkdownAstThematicBreak as Z, MarkdownTransformPluginDefinition as _, MarkdownNodeOf as a, isMarkdownExtensionNode as b, MarkdownPluginDefinition as c, MarkdownSyntaxContribution as d, MarkdownSyntaxPluginDefinition as f, MarkdownTransformContext as g, MarkdownTransform as h, MarkdownExtensionsOf as i, MarkdownAstHeading as j, MarkdownAstDataValue as k, MarkdownPluginEntry as l, MarkdownTokenizerInput as m, MarkdownExtensionRenderer as n, MarkdownPluginCapabilities as o, MarkdownTokenizeResult as p, MarkdownAstTable as q, MarkdownExtensionRenderers as r, MarkdownPluginData as s, MarkdownExtensionNode as t, MarkdownSyntaxCapability as u, createMarkdownPlugin as v, MarkdownAstBlockContent as w, isMarkdownPluginData as x, getMarkdownPluginCapabilities as y, MarkdownAstNode as z };

package/dist/publicParser-B6XMcsB2.d.ts

@@ -0,0 +1,141 @@
+import { K as MarkdownAstRoot, U as MarkdownAstPhrasingContent, l as MarkdownPluginEntry, t as MarkdownExtensionNode } from "./protocol-DwUmpC5G.js";
+//#region src/Markdown/legacyNodes.d.ts
+interface SourceRange {
+  readonly start: number;
+  readonly end: number;
+}
+type InlineNode<Extension extends MarkdownExtensionNode = never> = {
+  type: 'text';
+  content: string;
+} | {
+  type: 'bold';
+  children: InlineNode<Extension>[];
+} | {
+  type: 'italic';
+  children: InlineNode<Extension>[];
+} | {
+  type: 'strikethrough';
+  children: InlineNode<Extension>[];
+} | {
+  type: 'code';
+  content: string;
+} | {
+  type: 'link';
+  href: string;
+  children: InlineNode<Extension>[];
+} | {
+  type: 'image';
+  src: string;
+  alt: string;
+} | {
+  type: 'citation';
+  sourceId: string;
+} | {
+  type: 'break';
+} | Extract<Extension, {
+  display: 'inline';
+}>;
+interface MathInlineNode {
+  type: 'math';
+  value: string;
+}
+type InlineNodeWithMath<Extension extends MarkdownExtensionNode = never> = Exclude<InlineNode<Extension>, Extract<Extension, {
+  display: 'inline';
+}>> | MathInlineNode | Extract<Extension, {
+  display: 'inline';
+}>;
+type TableAlignment = 'left' | 'center' | 'right' | null;
+interface ListItemNode<Extension extends MarkdownExtensionNode = never> {
+  checked?: boolean;
+  children: BlockNode<Extension>[];
+}
+interface TableCellNode<Extension extends MarkdownExtensionNode = never> {
+  children: InlineNode<Extension>[];
+}
+interface BlockMetadata {
+  range?: SourceRange;
+}
+type BlockNode<Extension extends MarkdownExtensionNode = never> = ({
+  type: 'heading';
+  level: 1 | 2 | 3 | 4 | 5 | 6;
+  children: InlineNode<Extension>[];
+} | {
+  type: 'paragraph';
+  children: InlineNode<Extension>[];
+} | {
+  type: 'codeblock';
+  language: string;
+  content: string;
+} | {
+  type: 'blockquote';
+  children: BlockNode<Extension>[];
+} | {
+  type: 'list';
+  ordered: boolean;
+  start?: number;
+  delimiter?: '.' | ')';
+  loose?: boolean;
+  items: ListItemNode<Extension>[];
+} | {
+  type: 'table';
+  headers: TableCellNode<Extension>[];
+  alignments: TableAlignment[];
+  rows: TableCellNode<Extension>[][];
+} | {
+  type: 'hr';
+} | {
+  type: 'image';
+  src: string;
+  alt: string;
+} | Extract<Extension, {
+  display: 'block';
+}>) & BlockMetadata;
+type MathBlockNode = {
+  type: 'math';
+  value: string;
+} & BlockMetadata;
+type BlockNodeWithMath<Extension extends MarkdownExtensionNode = never> = BlockNode<Extension> | MathBlockNode;
+//#endregion
+//#region src/Markdown/publicParser.d.ts
+interface ParseOptions {
+  /** `'gfm'` keeps bare URLs, `www.` hosts, and emails as links. */
+  readonly autolink?: 'gfm';
+  /** Attach `{ start, end }` source offsets on top-level legacy blocks. */
+  readonly sourceRanges?: boolean;
+  /** Ids that turn `[id]` and `【id】` into citation nodes. */
+  readonly sourceIds?: Iterable<string>;
+  readonly plugins?: readonly MarkdownPluginEntry[];
+  /**
+   * `false` while a stream is still open. An unclosed frontmatter fence then
+   * defers instead of being dropped. Defaults to `true`.
+   */
+  readonly isFinal?: boolean;
+  /**
+   * Accepted so callers can pass it. This parser does not emit math nodes.
+   */
+  readonly math?: boolean;
+}
+type MathParseOptions = ParseOptions;
+type IncrementalParseOptions = ParseOptions;
+type IncrementalMathParseOptions = ParseOptions;
+interface IncrementalState {
+  prevInput: string;
+  settledText: string;
+  settledBlocks: BlockNode[];
+  settledUpTo: number;
+}
+/** Canonical mdast-shaped root, including plugin syntax and transforms. */
+declare function parseMarkdownAst(source: string, options?: ParseOptions): MarkdownAstRoot;
+/** Phrasing children of `source`, read as inline content only. */
+declare function parseInlineAst(source: string, options?: ParseOptions): MarkdownAstPhrasingContent[];
+/** Legacy block list. `sourceRanges` adds offsets on the top-level blocks. */
+declare function parseMarkdown(source: string, options?: ParseOptions): BlockNode[];
+declare function parseInline(source: string, options?: ParseOptions): InlineNode[];
+declare function createIncrementalState(): IncrementalState;
+/**
+ * Public incremental entry. The result matches a full parse. The state records
+ * the latest source so a later call can see what was already settled.
+ */
+declare function parseMarkdownIncremental(source: string, state: IncrementalState, options?: ParseOptions): BlockNode[];
+//#endregion
+export { MathBlockNode as _, ParseOptions as a, TableAlignment as b, parseInlineAst as c, parseMarkdownIncremental as d, BlockNode as f, ListItemNode as g, InlineNodeWithMath as h, MathParseOptions as i, parseMarkdown as l, InlineNode as m, IncrementalParseOptions as n, createIncrementalState as o, BlockNodeWithMath as p, IncrementalState as r, parseInline as s, IncrementalMathParseOptions as t, parseMarkdownAst as u, MathInlineNode as v, TableCellNode as x, SourceRange as y };