@blade-hq/agent-react 2612.0.0-beta.2 → 2612.0.0-beta.20

package/node_modules/@types/markdown-it/dist/markdown-it.d.ts

@@ -0,0 +1,5 @@
+import MarkdownIt = require("./index.cjs.js");
+
+export as namespace markdownit;
+
+export = MarkdownIt;

package/node_modules/@types/markdown-it/dist/markdown-it.min.d.ts

@@ -0,0 +1,5 @@
+import MarkdownIt = require("./index.cjs.js");
+
+export as namespace markdownit;
+
+export = MarkdownIt;

package/node_modules/@types/markdown-it/index.d.mts

@@ -0,0 +1 @@
+export { default, Options, PluginSimple, PluginWithOptions, PluginWithParams, PresetName } from "./lib/index.mjs";

package/node_modules/@types/markdown-it/index.d.ts

@@ -0,0 +1,3 @@
+import MarkdownIt = require("./dist/index.cjs.js");
+
+export = MarkdownIt;

package/node_modules/@types/markdown-it/lib/common/html_blocks.d.mts

@@ -0,0 +1,7 @@
+/**
+ * List of valid html blocks names, according to commonmark spec
+ * @see https://spec.commonmark.org/0.30/#html-blocks
+ */
+declare const htmlBlocks: string[];
+
+export default htmlBlocks;

package/node_modules/@types/markdown-it/lib/common/html_re.d.mts

@@ -0,0 +1,2 @@
+export const HTML_TAG_RE: RegExp;
+export const HTML_OPEN_CLOSE_TAG_RE: RegExp;

package/node_modules/@types/markdown-it/lib/common/utils.d.mts

@@ -0,0 +1,62 @@
+import * as mdurl from "mdurl";
+// import * as ucmicro from "uc.micro";
+
+export const lib: {
+    mdurl: typeof mdurl;
+    ucmicro: any;
+};
+
+/**
+ * Merge objects
+ */
+export function assign(obj: any, ...from: any[]): any;
+
+export function isString(obj: any): obj is string;
+
+export function has(obj: any, key: keyof any): boolean;
+
+export function unescapeMd(str: string): string;
+
+export function unescapeAll(str: string): string;
+
+export function isValidEntityCode(c: number): boolean;
+
+export function fromCodePoint(c: number): string;
+
+export function escapeHtml(str: string): string;
+
+/**
+ * Remove element from array and put another array at those position.
+ * Useful for some operations with tokens
+ */
+export function arrayReplaceAt<T>(src: T[], pos: number, newElements: T[]): T[];
+
+export function isSpace(code: number): boolean;
+
+/**
+ * Zs (unicode class) || [\t\f\v\r\n]
+ */
+export function isWhiteSpace(code: number): boolean;
+
+/**
+ * Markdown ASCII punctuation characters.
+ *
+ * !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
+ *
+ * Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
+ *
+ * @see http://spec.commonmark.org/0.15/#ascii-punctuation-character
+ */
+export function isMdAsciiPunct(code: number): boolean;
+
+/**
+ * Currently without astral characters support.
+ */
+export function isPunctChar(ch: string): boolean;
+
+export function escapeRE(str: string): string;
+
+/**
+ * Helper to unify [reference labels].
+ */
+export function normalizeReference(str: string): string;

package/node_modules/@types/markdown-it/lib/helpers/index.d.mts

@@ -0,0 +1,5 @@
+import parseLinkDestination from "./parse_link_destination.mjs";
+import parseLinkLabel from "./parse_link_label.mjs";
+import parseLinkTitle from "./parse_link_title.mjs";
+
+export { parseLinkDestination, parseLinkLabel, parseLinkTitle };

package/node_modules/@types/markdown-it/lib/helpers/parse_link_destination.d.mts

@@ -0,0 +1,7 @@
+export interface ParseLinkDestinationResult {
+    ok: boolean;
+    pos: number;
+    str: string;
+}
+
+export default function parseLinkDestination(str: string, start: number, max: number): ParseLinkDestinationResult;

package/node_modules/@types/markdown-it/lib/helpers/parse_link_label.d.mts

@@ -0,0 +1,3 @@
+import StateInline from "../rules_inline/state_inline.mjs";
+
+export default function parseLinkLabel(state: StateInline, start: number, disableNested?: boolean): number;

package/node_modules/@types/markdown-it/lib/helpers/parse_link_title.d.mts

@@ -0,0 +1,29 @@
+export interface ParseLinkTitleResult {
+    /**
+     * if `true`, this is a valid link title
+     */
+    ok: boolean;
+    /**
+     * if `true`, this link can be continued on the next line
+     */
+    can_continue: boolean;
+    /**
+     * if `ok`, it's the position of the first character after the closing marker
+     */
+    pos: number;
+    /**
+     * if `ok`, it's the unescaped title
+     */
+    str: string;
+    /**
+     * expected closing marker character code
+     */
+    marker: number;
+}
+
+export default function parseLinkTitle(
+    str: string,
+    start: number,
+    max: number,
+    prev_state?: ParseLinkTitleResult,
+): ParseLinkTitleResult;

package/node_modules/@types/markdown-it/lib/index.d.mts

@@ -0,0 +1,404 @@
+import LinkifyIt from "linkify-it";
+
+import * as utils from "./common/utils.mjs";
+import * as helpers from "./helpers/index.mjs";
+import ParserBlock from "./parser_block.mjs";
+import ParserCore from "./parser_core.mjs";
+import ParserInline from "./parser_inline.mjs";
+import Renderer from "./renderer.mjs";
+import Token from "./token.mjs";
+
+/**
+ * MarkdownIt provides named presets as a convenience to quickly
+ * enable/disable active syntax rules and options for common use cases.
+ *
+ * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -
+ *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
+ * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -
+ *   similar to GFM, used when no preset name given. Enables all available rules,
+ *   but still without html, typographer & autolinker.
+ * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -
+ *   all rules disabled. Useful to quickly setup your config via `.enable()`.
+ *   For example, when you need only `bold` and `italic` markup and nothing else.
+ */
+export type PresetName = "default" | "zero" | "commonmark";
+
+export interface Options {
+    /**
+     * Set `true` to enable HTML tags in source. Be careful!
+     * That's not safe! You may need external sanitizer to protect output from XSS.
+     * It's better to extend features via plugins, instead of enabling HTML.
+     * @default false
+     */
+    html?: boolean | undefined;
+
+    /**
+     * Set `true` to add '/' when closing single tags
+     * (`<br />`). This is needed only for full CommonMark compatibility. In real
+     * world you will need HTML output.
+     * @default false
+     */
+    xhtmlOut?: boolean | undefined;
+
+    /**
+     * Set `true` to convert `\n` in paragraphs into `<br>`.
+     * @default false
+     */
+    breaks?: boolean | undefined;
+
+    /**
+     * CSS language class prefix for fenced blocks.
+     * Can be useful for external highlighters.
+     * @default 'language-'
+     */
+    langPrefix?: string | undefined;
+
+    /**
+     * Set `true` to autoconvert URL-like text to links.
+     * @default false
+     */
+    linkify?: boolean | undefined;
+
+    /**
+     * Set `true` to enable [some language-neutral replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +
+     * quotes beautification (smartquotes).
+     * @default false
+     */
+    typographer?: boolean | undefined;
+
+    /**
+     * Double + single quotes replacement
+     * pairs, when typographer enabled and smartquotes on. For example, you can
+     * use `'«»„“'` for Russian, `'„“‚‘'` for German, and
+     * `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
+     * @default '“”‘’'
+     */
+    quotes?: string | string[];
+
+    /**
+     * Highlighter function for fenced code blocks.
+     * Highlighter `function (str, lang, attrs)` should return escaped HTML. It can
+     * also return empty string if the source was not changed and should be escaped
+     * externally. If result starts with <pre... internal wrapper is skipped.
+     * @default null
+     */
+    highlight?: ((str: string, lang: string, attrs: string) => string) | null | undefined;
+}
+
+export type PluginSimple = (md: MarkdownIt) => void;
+export type PluginWithOptions<T = any> = (md: MarkdownIt, options?: T) => void;
+export type PluginWithParams = (md: MarkdownIt, ...params: any[]) => void;
+
+interface MarkdownItConstructor {
+    new(): MarkdownIt;
+    new(presetName: PresetName, options?: Options): MarkdownIt;
+    new(options: Options): MarkdownIt;
+    (): MarkdownIt;
+    (presetName: PresetName, options?: Options): MarkdownIt;
+    (options: Options): MarkdownIt;
+}
+
+interface MarkdownIt {
+    /**
+     * Instance of {@link ParserInline}. You may need it to add new rules when
+     * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
+     * {@link MarkdownIt.enable}.
+     */
+    readonly inline: ParserInline;
+
+    /**
+     * Instance of {@link ParserBlock}. You may need it to add new rules when
+     * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
+     * {@link MarkdownIt.enable}.
+     */
+    readonly block: ParserBlock;
+
+    /**
+     * Instance of {@link Core} chain executor. You may need it to add new rules when
+     * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
+     * {@link MarkdownIt.enable}.
+     */
+    readonly core: ParserCore;
+
+    /**
+     * Instance of {@link Renderer}. Use it to modify output look. Or to add rendering
+     * rules for new token types, generated by plugins.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * function myToken(tokens, idx, options, env, self) {
+     *   //...
+     *   return result;
+     * };
+     *
+     * md.renderer.rules['my_token'] = myToken
+     * ```
+     *
+     * See {@link Renderer} docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
+     */
+    readonly renderer: Renderer;
+
+    /**
+     * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
+     * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)
+     * rule.
+     */
+    readonly linkify: LinkifyIt;
+
+    /**
+     * Link validation function. CommonMark allows too much in links. By default
+     * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
+     * except some embedded image types.
+     *
+     * You can change this behaviour:
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     * // enable everything
+     * md.validateLink = function () { return true; }
+     * ```
+     */
+    validateLink(url: string): boolean;
+
+    /**
+     * Function used to encode link url to a machine-readable format,
+     * which includes url-encoding, punycode, etc.
+     */
+    normalizeLink(url: string): string;
+
+    /**
+     * Function used to decode link url to a human-readable format`
+     */
+    normalizeLinkText(url: string): string;
+
+    readonly utils: typeof utils;
+
+    readonly helpers: typeof helpers;
+
+    readonly options: Options;
+
+    /**
+     * *chainable*
+     *
+     * Set parser options (in the same format as in constructor). Probably, you
+     * will never need it, but you can change options after constructor call.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')()
+     *             .set({ html: true, breaks: true })
+     *             .set({ typographer: true });
+     * ```
+     *
+     * __Note:__ To achieve the best possible performance, don't modify a
+     * `markdown-it` instance options on the fly. If you need multiple configurations
+     * it's best to create multiple instances and initialize each with separate
+     * config.
+     */
+    set(options: Options): this;
+
+    /**
+     * *chainable*, *internal*
+     *
+     * Batch load of all options and compenent settings. This is internal method,
+     * and you probably will not need it. But if you with - see available presets
+     * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
+     *
+     * We strongly recommend to use presets instead of direct config loads. That
+     * will give better compatibility with next versions.
+     */
+    configure(presets: PresetName): this;
+
+    /**
+     * *chainable*
+     *
+     * Enable list or rules. It will automatically find appropriate components,
+     * containing rules with given names. If rule not found, and `ignoreInvalid`
+     * not set - throws exception.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')()
+     *             .enable(['sub', 'sup'])
+     *             .disable('smartquotes');
+     * ```
+     *
+     * @param list rule name or list of rule names to enable
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    enable(list: string | string[], ignoreInvalid?: boolean): this;
+
+    /**
+     * *chainable*
+     *
+     * The same as {@link MarkdownIt.enable}, but turn specified rules off.
+     *
+     * @param list rule name or list of rule names to disable.
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    disable(list: string | string[], ignoreInvalid?: boolean): this;
+
+    /**
+     * *chainable*
+     *
+     * Load specified plugin with given params into current parser instance.
+     * It's just a sugar to call `plugin(md, params)` with curring.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var iterator = require('markdown-it-for-inline');
+     * var md = require('markdown-it')()
+     *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
+     *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
+     *             });
+     * ```
+     */
+    use(plugin: PluginSimple): this;
+    use<T = any>(plugin: PluginWithOptions<T>, options?: T): this;
+    use(plugin: PluginWithParams, ...params: any[]): this;
+
+    /**
+     * *internal*
+     *
+     * Parse input string and returns list of block tokens (special token type
+     * "inline" will contain list of inline tokens). You should not call this
+     * method directly, until you write custom renderer (for example, to produce
+     * AST).
+     *
+     * `env` is used to pass data between "distributed" rules and return additional
+     * metadata like reference info, needed for the renderer. It also can be used to
+     * inject data in specific cases. Usually, you will be ok to pass `{}`,
+     * and then pass updated object to renderer.
+     *
+     * @param src source string
+     * @param env environment sandbox
+     */
+    parse(src: string, env: any): Token[];
+
+    /**
+     * Render markdown string into html. It does all magic for you :).
+     *
+     * `env` can be used to inject additional metadata (`{}` by default).
+     * But you will not need it with high probability. See also comment
+     * in {@link MarkdownIt.parse}.
+     *
+     * @param src source string
+     * @param env environment sandbox
+     */
+    render(src: string, env?: any): string;
+
+    /**
+     * *internal*
+     *
+     * The same as {@link MarkdownIt.parse} but skip all block rules. It returns the
+     * block tokens list with the single `inline` element, containing parsed inline
+     * tokens in `children` property. Also updates `env` object.
+     *
+     * @param src source string
+     * @param env environment sandbox
+     */
+    parseInline(src: string, env: any): Token[];
+
+    /**
+     * Similar to {@link MarkdownIt.render} but for single paragraph content. Result
+     * will NOT be wrapped into `<p>` tags.
+     *
+     * @param src source string
+     * @param env environment sandbox
+     */
+    renderInline(src: string, env?: any): string;
+}
+
+/**
+ * Main parser/renderer class.
+ *
+ * ##### Usage
+ *
+ * ```javascript
+ * // node.js, "classic" way:
+ * var MarkdownIt = require('markdown-it'),
+ *     md = new MarkdownIt();
+ * var result = md.render('# markdown-it rulezz!');
+ *
+ * // node.js, the same, but with sugar:
+ * var md = require('markdown-it')();
+ * var result = md.render('# markdown-it rulezz!');
+ *
+ * // browser without AMD, added to "window" on script load
+ * // Note, there are no dash.
+ * var md = window.markdownit();
+ * var result = md.render('# markdown-it rulezz!');
+ * ```
+ *
+ * Single line rendering, without paragraph wrap:
+ *
+ * ```javascript
+ * var md = require('markdown-it')();
+ * var result = md.renderInline('__markdown-it__ rulezz!');
+ * ```
+ *
+ * ##### Example
+ *
+ * ```javascript
+ * // commonmark mode
+ * var md = require('markdown-it')('commonmark');
+ *
+ * // default mode
+ * var md = require('markdown-it')();
+ *
+ * // enable everything
+ * var md = require('markdown-it')({
+ *   html: true,
+ *   linkify: true,
+ *   typographer: true
+ * });
+ * ```
+ *
+ * ##### Syntax highlighting
+ *
+ * ```js
+ * var hljs = require('highlight.js') // https://highlightjs.org/
+ *
+ * var md = require('markdown-it')({
+ *   highlight: function (str, lang) {
+ *     if (lang && hljs.getLanguage(lang)) {
+ *       try {
+ *         return hljs.highlight(lang, str, true).value;
+ *       } catch (__) {}
+ *     }
+ *
+ *     return ''; // use external default escaping
+ *   }
+ * });
+ * ```
+ *
+ * Or with full wrapper override (if you need assign class to `<pre>`):
+ *
+ * ```javascript
+ * var hljs = require('highlight.js') // https://highlightjs.org/
+ *
+ * // Actual default values
+ * var md = require('markdown-it')({
+ *   highlight: function (str, lang) {
+ *     if (lang && hljs.getLanguage(lang)) {
+ *       try {
+ *         return '<pre class="hljs"><code>' +
+ *                hljs.highlight(lang, str, true).value +
+ *                '</code></pre>';
+ *       } catch (__) {}
+ *     }
+ *
+ *     return '<pre class="hljs"><code>' + md.utils.escapeHtml(str) + '</code></pre>';
+ *   }
+ * });
+ * ```
+ */
+declare const MarkdownIt: MarkdownItConstructor;
+
+export default MarkdownIt;

package/node_modules/@types/markdown-it/lib/parser_block.d.mts

@@ -0,0 +1,25 @@
+import MarkdownIt from "./index.mjs";
+import Ruler from "./ruler.mjs";
+import StateBlock from "./rules_block/state_block.mjs";
+import Token from "./token.mjs";
+
+export type RuleBlock = (state: StateBlock, startLine: number, endLine: number, silent: boolean) => boolean;
+
+export default class ParserBlock {
+    /**
+     * {@link Ruler} instance. Keep configuration of block rules.
+     */
+    ruler: Ruler<RuleBlock>;
+
+    /**
+     * Generate tokens for input range
+     */
+    tokenize(state: StateBlock, startLine: number, endLine: number): void;
+
+    /**
+     * Process input string and push block tokens into `outTokens`
+     */
+    parse(str: string, md: MarkdownIt, env: any, outTokens: Token[]): void;
+
+    State: typeof StateBlock;
+}

package/node_modules/@types/markdown-it/lib/parser_core.d.mts

@@ -0,0 +1,18 @@
+import Ruler from "./ruler.mjs";
+import StateCore from "./rules_core/state_core.mjs";
+
+export type RuleCore = (state: StateCore) => void;
+
+export default class Core {
+    /**
+     * {@link Ruler} instance. Keep configuration of core rules.
+     */
+    ruler: Ruler<RuleCore>;
+
+    /**
+     * Executes core chain rules.
+     */
+    process(state: StateCore): void;
+
+    State: typeof StateCore;
+}

package/node_modules/@types/markdown-it/lib/parser_inline.d.mts

@@ -0,0 +1,38 @@
+import MarkdownIt from "./index.mjs";
+import Ruler from "./ruler.mjs";
+import StateInline from "./rules_inline/state_inline.mjs";
+import Token from "./token.mjs";
+
+export type RuleInline = (state: StateInline, silent: boolean) => boolean;
+export type RuleInline2 = (state: StateInline) => boolean;
+
+export default class ParserInline {
+    /**
+     * {@link Ruler} instance. Keep configuration of inline rules.
+     */
+    ruler: Ruler<RuleInline>;
+
+    /**
+     * {@link Ruler} instance. Second ruler used for post-processing
+     * (e.g. in emphasis-like rules).
+     */
+    ruler2: Ruler<RuleInline2>;
+
+    /**
+     * Skip single token by running all rules in validation mode;
+     * returns `true` if any rule reported success
+     */
+    skipToken(state: StateInline): void;
+
+    /**
+     * Generate tokens for input range
+     */
+    tokenize(state: StateInline): void;
+
+    /**
+     * Process input string and push inline tokens into `outTokens`
+     */
+    parse(str: string, md: MarkdownIt, env: any, outTokens: Token[]): void;
+
+    State: typeof StateInline;
+}