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

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

@@ -0,0 +1,96 @@
+import { Options } from "./index.mjs";
+import Token from "./token.mjs";
+
+export type RenderRule = (tokens: Token[], idx: number, options: Options, env: any, self: Renderer) => string;
+
+export interface RenderRuleRecord {
+    [type: string]: RenderRule | undefined;
+    code_inline?: RenderRule | undefined;
+    code_block?: RenderRule | undefined;
+    fence?: RenderRule | undefined;
+    image?: RenderRule | undefined;
+    hardbreak?: RenderRule | undefined;
+    softbreak?: RenderRule | undefined;
+    text?: RenderRule | undefined;
+    html_block?: RenderRule | undefined;
+    html_inline?: RenderRule | undefined;
+}
+
+export default class Renderer {
+    /**
+     * Creates new {@link Renderer} instance and fill {@link Renderer#rules} with defaults.
+     */
+    constructor();
+
+    /**
+     * Contains render rules for tokens. Can be updated and extended.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.renderer.rules.strong_open  = function () { return '<b>'; };
+     * md.renderer.rules.strong_close = function () { return '</b>'; };
+     *
+     * var result = md.renderInline(...);
+     * ```
+     *
+     * Each rule is called as independent static function with fixed signature:
+     *
+     * ```javascript
+     * function my_token_render(tokens, idx, options, env, renderer) {
+     *   // ...
+     *   return renderedHTML;
+     * }
+     * ```
+     *
+     * @see https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs
+     */
+    rules: RenderRuleRecord;
+
+    /**
+     * Render token attributes to string.
+     */
+    renderAttrs(token: Token): string;
+
+    /**
+     * Default token renderer. Can be overriden by custom function
+     * in {@link Renderer#rules}.
+     *
+     * @param tokens list of tokens
+     * @param idx token index to render
+     * @param options params of parser instance
+     */
+    renderToken(tokens: Token[], idx: number, options: Options): string;
+
+    /**
+     * The same as {@link Renderer.render}, but for single token of `inline` type.
+     *
+     * @param tokens list of block tokens to render
+     * @param options params of parser instance
+     * @param env additional data from parsed input (references, for example)
+     */
+    renderInline(tokens: Token[], options: Options, env: any): string;
+
+    /**
+     * Special kludge for image `alt` attributes to conform CommonMark spec.
+     * Don't try to use it! Spec requires to show `alt` content with stripped markup,
+     * instead of simple escaping.
+     *
+     * @param tokens list of block tokens to render
+     * @param options params of parser instance
+     * @param env additional data from parsed input (references, for example)
+     */
+    renderInlineAsText(tokens: Token[], options: Options, env: any): string;
+
+    /**
+     * Takes token stream and generates HTML. Probably, you will never need to call
+     * this method directly.
+     *
+     * @param tokens list of block tokens to render
+     * @param options params of parser instance
+     * @param env additional data from parsed input (references, for example)
+     */
+    render(tokens: Token[], options: Options, env: any): string;
+}

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

@@ -0,0 +1,158 @@
+export interface RuleOptions {
+    /**
+     * array with names of "alternate" chains.
+     */
+    alt: string[];
+}
+
+/**
+ * Helper class, used by {@link MarkdownIt#core}, {@link MarkdownIt#block} and
+ * {@link MarkdownIt#inline} to manage sequences of functions (rules):
+ *
+ * - keep rules in defined order
+ * - assign the name to each rule
+ * - enable/disable rules
+ * - add/replace rules
+ * - allow assign rules to additional named chains (in the same)
+ * - caching lists of active rules
+ *
+ * You will not need use this class directly until write plugins. For simple
+ * rules control use {@link MarkdownIt.disable}, {@link MarkdownIt.enable} and
+ * {@link MarkdownIt.use}.
+ */
+export default class Ruler<T> {
+    constructor();
+
+    /**
+     * Replace rule by name with new function & options. Throws error if name not
+     * found.
+     *
+     * ##### Example
+     *
+     * Replace existing typographer replacement rule with new one:
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.core.ruler.at('replacements', function replace(state) {
+     *   //...
+     * });
+     * ```
+     *
+     * @param name rule name to replace.
+     * @param fn new rule function.
+     * @param options new rule options (not mandatory).
+     */
+    at(name: string, fn: T, options?: RuleOptions): void;
+
+    /**
+     * Add new rule to chain before one with given name.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
+     *   //...
+     * });
+     * ```
+     *
+     * @see {@link Ruler.after}, {@link Ruler.push}
+     *
+     * @param beforeName new rule will be added before this one.
+     * @param ruleName name of added rule.
+     * @param fn rule function.
+     * @param options rule options (not mandatory).
+     */
+    before(beforeName: string, ruleName: string, fn: T, options?: RuleOptions): void;
+
+    /**
+     * Add new rule to chain after one with given name.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.inline.ruler.after('text', 'my_rule', function replace(state) {
+     *   //...
+     * });
+     * ```
+     *
+     * @see {@link Ruler.before}, {@link Ruler.push}
+     *
+     * @param afterName new rule will be added after this one.
+     * @param ruleName name of added rule.
+     * @param fn rule function.
+     * @param options rule options (not mandatory).
+     */
+    after(afterName: string, ruleName: string, fn: T, options?: RuleOptions): void;
+
+    /**
+     * Push new rule to the end of chain.
+     *
+     * ##### Example
+     *
+     * ```javascript
+     * var md = require('markdown-it')();
+     *
+     * md.core.ruler.push('my_rule', function replace(state) {
+     *   //...
+     * });
+     * ```
+     *
+     * @see {@link Ruler.before}, {@link Ruler.after}
+     *
+     * @param ruleName name of added rule.
+     * @param fn rule function.
+     * @param options rule options (not mandatory).
+     */
+    push(ruleName: string, fn: T, options?: RuleOptions): void;
+
+    /**
+     * Enable rules with given names. If any rule name not found - throw Error.
+     * Errors can be disabled by second param.
+     *
+     * Returns list of found rule names (if no exception happened).
+     *
+     * @see {@link Ruler.disable}, {@link Ruler.enableOnly}
+     *
+     * @param list list of rule names to enable.
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    enable(list: string | string[], ignoreInvalid?: boolean): string[];
+
+    /**
+     * Enable rules with given names, and disable everything else. If any rule name
+     * not found - throw Error. Errors can be disabled by second param.
+     *
+     * @see {@link Ruler.disable}, {@link Ruler.enable}
+     *
+     * @param list list of rule names to enable (whitelist).
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    enableOnly(list: string | string[], ignoreInvalid?: boolean): void;
+
+    /**
+     * Disable rules with given names. If any rule name not found - throw Error.
+     * Errors can be disabled by second param.
+     *
+     * Returns list of found rule names (if no exception happened).
+     *
+     * @see {@link Ruler.enable}, {@link Ruler.enableOnly}
+     *
+     * @param list list of rule names to disable.
+     * @param ignoreInvalid set `true` to ignore errors when rule not found.
+     */
+    disable(list: string | string[], ignoreInvalid?: boolean): string[];
+
+    /**
+     * Return array of active functions (rules) for given chain name. It analyzes
+     * rules configuration, compiles caches if not exists and returns result.
+     *
+     * Default chain name is `''` (empty string). It can't be skipped. That's
+     * done intentionally, to keep signature monomorphic for high speed.
+     */
+    getRules(chainName: string): T[];
+}

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

@@ -0,0 +1,124 @@
+import MarkdownIt from "../index.mjs";
+import Token, { Nesting } from "../token.mjs";
+
+export type ParentType = "blockquote" | "list" | "root" | "paragraph" | "reference";
+
+export default class StateBlock {
+    constructor(src: string, md: MarkdownIt, env: any, tokens: Token[]);
+
+    src: string;
+
+    /**
+     * link to parser instance
+     */
+    md: MarkdownIt;
+
+    env: any;
+
+    //
+    // Internal state vartiables
+    //
+
+    tokens: Token[];
+
+    /**
+     * line begin offsets for fast jumps
+     */
+    bMarks: number[];
+    /**
+     * line end offsets for fast jumps
+     */
+    eMarks: number[];
+    /**
+     * offsets of the first non-space characters (tabs not expanded)
+     */
+    tShift: number[];
+    /**
+     * indents for each line (tabs expanded)
+     */
+    sCount: number[];
+
+    /**
+     * An amount of virtual spaces (tabs expanded) between beginning
+     * of each line (bMarks) and real beginning of that line.
+     *
+     * It exists only as a hack because blockquotes override bMarks
+     * losing information in the process.
+     *
+     * It's used only when expanding tabs, you can think about it as
+     * an initial tab length, e.g. bsCount=21 applied to string `\t123`
+     * means first tab should be expanded to 4-21%4 === 3 spaces.
+     */
+    bsCount: number[];
+
+    // block parser variables
+
+    /**
+     * required block content indent (for example, if we are
+     * inside a list, it would be positioned after list marker)
+     */
+    blkIndent: number;
+    /**
+     * line index in src
+     */
+    line: number;
+    /**
+     * lines count
+     */
+    lineMax: number;
+    /**
+     * loose/tight mode for lists
+     */
+    tight: boolean;
+    /**
+     * indent of the current dd block (-1 if there isn't any)
+     */
+    ddIndent: number;
+    /**
+     * indent of the current list block (-1 if there isn't any)
+     */
+    listIndent: number;
+
+    /**
+     * used in lists to determine if they interrupt a paragraph
+     */
+    parentType: ParentType;
+
+    level: number;
+
+    /**
+     * Push new token to "stream".
+     */
+    push(type: string, tag: string, nesting: Nesting): Token;
+
+    isEmpty(line: number): boolean;
+
+    skipEmptyLines(from: number): number;
+
+    /**
+     * Skip spaces from given position.
+     */
+    skipSpaces(pos: number): number;
+
+    /**
+     * Skip spaces from given position in reverse.
+     */
+    skipSpacesBack(pos: number, min: number): number;
+
+    /**
+     * Skip char codes from given position
+     */
+    skipChars(pos: number, code: number): number;
+
+    /**
+     * Skip char codes reverse from given position - 1
+     */
+    skipCharsBack(pos: number, code: number, min: number): number;
+
+    /**
+     * cut lines range from source.
+     */
+    getLines(begin: number, end: number, indent: number, keepLastLF: boolean): string;
+
+    Token: typeof Token;
+}

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

@@ -0,0 +1,18 @@
+import MarkdownIt from "../index.mjs";
+import Token from "../token.mjs";
+
+export default class StateCore {
+    constructor(src: string, md: MarkdownIt, env: any);
+
+    src: string;
+    env: any;
+    tokens: Token[];
+    inlineMode: boolean;
+
+    /**
+     * link to parser instance
+     */
+    md: MarkdownIt;
+
+    Token: typeof Token;
+}

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

@@ -0,0 +1,73 @@
+import MarkdownIt from "../index.mjs";
+import Token, { Nesting } from "../token.mjs";
+
+export interface Scanned {
+    can_open: boolean;
+    can_close: boolean;
+    length: number;
+}
+
+export interface Delimiter {
+    marker: number;
+    length: number;
+    token: number;
+    end: number;
+    open: boolean;
+    close: boolean;
+}
+
+export interface TokenMeta {
+    delimiters: Delimiter[];
+}
+
+export default class StateInline {
+    constructor(src: string, md: MarkdownIt, env: any, outTokens: Token[]);
+
+    src: string;
+    env: any;
+    md: MarkdownIt;
+    tokens: Token[];
+    tokens_meta: Array<TokenMeta | null>;
+
+    pos: number;
+    posMax: number;
+    level: number;
+    pending: string;
+    pendingLevel: number;
+
+    /**
+     * Stores { start: end } pairs. Useful for backtrack
+     * optimization of pairs parse (emphasis, strikes).
+     */
+    cache: any;
+
+    /**
+     * List of emphasis-like delimiters for current tag
+     */
+    delimiters: Delimiter[];
+
+    // Stack of delimiter lists for upper level tags
+    // _prev_delimiters: StateInline.Delimiter[][];
+
+    /**
+     * Flush pending text
+     */
+    pushPending(): Token;
+
+    /**
+     * Push new token to "stream".
+     * If pending text exists - flush it as text token
+     */
+    push(type: string, tag: string, nesting: Nesting): Token;
+
+    /**
+     * Scan a sequence of emphasis-like markers, and determine whether
+     * it can start an emphasis sequence or end an emphasis sequence.
+     *
+     * @param start position to scan from (it should point at a valid marker)
+     * @param canSplitWord determine if these markers can be found inside a word
+     */
+    scanDelims(start: number, canSplitWord: boolean): Scanned;
+
+    Token: typeof Token;
+}

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

@@ -0,0 +1,108 @@
+export type Nesting = 1 | 0 | -1;
+
+export default class Token {
+    /**
+     * Create new token and fill passed properties.
+     */
+    constructor(type: string, tag: string, nesting: Nesting);
+
+    /**
+     * Type of the token, e.g. "paragraph_open"
+     */
+    type: string;
+
+    /**
+     * HTML tag name, e.g. "p"
+     */
+    tag: string;
+
+    /**
+     * HTML attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
+     */
+    attrs: Array<[string, string]> | null;
+
+    /**
+     * Source map info. Format: `[ line_begin, line_end ]`
+     */
+    map: [number, number] | null;
+
+    /**
+     * Level change (number in {-1, 0, 1} set), where:
+     *
+     * -  `1` means the tag is opening
+     * -  `0` means the tag is self-closing
+     * - `-1` means the tag is closing
+     */
+    nesting: Nesting;
+
+    /**
+     * Nesting level, the same as `state.level`
+     */
+    level: number;
+
+    /**
+     * An array of child nodes (inline and img tokens)
+     */
+    children: Token[] | null;
+
+    /**
+     * In a case of self-closing tag (code, html, fence, etc.),
+     * it has contents of this tag.
+     */
+    content: string;
+
+    /**
+     * '*' or '_' for emphasis, fence string for fence, etc.
+     */
+    markup: string;
+
+    /**
+     * - Info string for "fence" tokens
+     * - The value "auto" for autolink "link_open" and "link_close" tokens
+     * - The string value of the item marker for ordered-list "list_item_open" tokens
+     */
+    info: string;
+
+    /**
+     * A place for plugins to store an arbitrary data
+     */
+    meta: any;
+
+    /**
+     * True for block-level tokens, false for inline tokens.
+     * Used in renderer to calculate line breaks
+     */
+    block: boolean;
+
+    /**
+     * If it's true, ignore this element when rendering. Used for tight lists
+     * to hide paragraphs.
+     */
+    hidden: boolean;
+
+    /**
+     * Search attribute index by name.
+     */
+    attrIndex(name: string): number;
+
+    /**
+     * Add `[ name, value ]` attribute to list. Init attrs if necessary
+     */
+    attrPush(attrData: [string, string]): void;
+
+    /**
+     * Set `name` attribute to `value`. Override old value if exists.
+     */
+    attrSet(name: string, value: string): void;
+
+    /**
+     * Get the value of attribute `name`, or null if it does not exist.
+     */
+    attrGet(name: string): string | null;
+
+    /**
+     * Join value to existing attribute via space. Or create new attribute if not
+     * exists. Useful to operate with token classes.
+     */
+    attrJoin(name: string, value: string): void;
+}

package/node_modules/@types/markdown-it/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "@types/markdown-it",
+    "version": "14.1.2",
+    "description": "TypeScript definitions for markdown-it",
+    "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/markdown-it",
+    "license": "MIT",
+    "contributors": [
+        {
+            "name": "York Yao",
+            "githubUsername": "plantain-00",
+            "url": "https://github.com/plantain-00"
+        },
+        {
+            "name": "Robert Coie",
+            "githubUsername": "rapropos",
+            "url": "https://github.com/rapropos"
+        },
+        {
+            "name": "duduluu",
+            "githubUsername": "duduluu",
+            "url": "https://github.com/duduluu"
+        },
+        {
+            "name": "Piotr Błażejewicz",
+            "githubUsername": "peterblazejewicz",
+            "url": "https://github.com/peterblazejewicz"
+        }
+    ],
+    "main": "",
+    "types": "index.d.ts",
+    "exports": {
+        ".": {
+            "import": "./index.d.mts",
+            "require": "./dist/index.cjs.d.ts"
+        },
+        "./*": {
+            "import": "./*",
+            "require": "./*"
+        },
+        "./package.json": "./package.json"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
+        "directory": "types/markdown-it"
+    },
+    "scripts": {},
+    "dependencies": {
+        "@types/linkify-it": "^5",
+        "@types/mdurl": "^2"
+    },
+    "typesPublisherContentHash": "72b750af20eb4973f000b8b6a751de43787503125afcd200798f88f096b221e7",
+    "typeScriptVersion": "4.8"
+}

package/node_modules/@types/mdurl/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/node_modules/@types/mdurl/README.md

@@ -0,0 +1,15 @@
+# Installation
+> `npm install --save @types/mdurl`
+
+# Summary
+This package contains type definitions for mdurl (https://github.com/markdown-it/mdurl#readme).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mdurl.
+
+### Additional Details
+ * Last updated: Wed, 01 May 2024 18:07:45 GMT
+ * Dependencies: none
+
+# Credits
+These definitions were written by [Junyoung Choi](https://github.com/rokt33r).