@nodetool-ai/base-nodes 0.7.0-rc.11

package/dist/nodes/text-extra.js

@@ -0,0 +1,2226 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BaseNode, prop } from "@nodetool-ai/node-sdk";
+import { promises as fs } from "node:fs";
+import { extname, join } from "node:path";
+function flagsFromOpts(opts) {
+    let flags = "";
+    if (opts.ignorecase)
+        flags += "i";
+    if (opts.multiline)
+        flags += "m";
+    if (opts.dotall)
+        flags += "s";
+    return flags;
+}
+function toTitleCase(value) {
+    return value.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.slice(1).toLowerCase());
+}
+function folderPath(value) {
+    if (typeof value === "string")
+        return value;
+    if (!value || typeof value !== "object")
+        return "";
+    const record = value;
+    if (typeof record.path === "string")
+        return record.path;
+    if (typeof record.uri === "string") {
+        return record.uri.startsWith("file://")
+            ? record.uri.slice("file://".length)
+            : record.uri;
+    }
+    return "";
+}
+function modelConfig(props) {
+    const model = (props.model ?? {});
+    return {
+        providerId: typeof model.provider === "string" ? model.provider : "",
+        modelId: typeof model.id === "string" ? model.id : ""
+    };
+}
+export class SplitTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Split";
+    static title = "Split Text";
+    static description = "Separates text into a list of strings based on a specified delimiter.\n    text, split, tokenize";
+    static metadataOutputTypes = {
+        output: "list[str]"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const delimiter = String(this.delimiter ?? this.delimiter ?? ",");
+        return { output: text.split(delimiter) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], SplitTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: ",", title: "Delimiter" })
+], SplitTextNode.prototype, "delimiter", void 0);
+export class ExtractTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Extract";
+    static title = "Extract Text";
+    static description = "Extracts a substring from input text.\n    text, extract, substring";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const start = Number(this.start ?? this.start ?? 0);
+        const end = Number(this.end ?? this.end ?? 0);
+        return { output: text.slice(start, end) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], ExtractTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Start" })
+], ExtractTextNode.prototype, "start", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "End" })
+], ExtractTextNode.prototype, "end", void 0);
+export class ChunkTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Chunk";
+    static title = "Split Text into Chunks";
+    static description = "Splits text into chunks of specified word length.\n    text, chunk, split";
+    static metadataOutputTypes = {
+        output: "list[str]"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const length = Number(this.length ?? this.length ?? 100);
+        const overlap = Number(this.overlap ?? this.overlap ?? 0);
+        const separator = String(this.separator ?? this.separator ?? " ");
+        const step = length - overlap;
+        if (length < 1 || step <= 0) {
+            throw new Error("Invalid chunk parameters");
+        }
+        const words = text.split(separator);
+        const chunks = [];
+        for (let i = 0; i < words.length; i += step) {
+            chunks.push(words.slice(i, i + length).join(" "));
+        }
+        return { output: chunks };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], ChunkTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "int", default: 100, title: "Length", min: 1, max: 1000 })
+], ChunkTextNode.prototype, "length", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Overlap" })
+], ChunkTextNode.prototype, "overlap", void 0);
+__decorate([
+    prop({ type: "str", default: " ", title: "Separator" })
+], ChunkTextNode.prototype, "separator", void 0);
+export class ExtractRegexNode extends BaseNode {
+    static nodeType = "nodetool.text.ExtractRegex";
+    static title = "Extract Regex Groups";
+    static description = "Extracts substrings matching regex groups from text.\n    text, regex, extract\n\n    Use cases:\n    - Extracting structured data (e.g., dates, emails) from unstructured text\n    - Parsing specific patterns in log files or documents\n    - Isolating relevant information from complex text formats";
+    static metadataOutputTypes = {
+        output: "list[str]"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const pattern = String(this.regex ?? this.regex ?? "");
+        const flags = flagsFromOpts({
+            dotall: this.dotall ?? this.dotall,
+            ignorecase: this.ignorecase ?? this.ignorecase,
+            multiline: this.multiline ?? this.multiline
+        });
+        const match = new RegExp(pattern, flags).exec(text);
+        if (!match) {
+            return { output: [] };
+        }
+        return { output: match.slice(1) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], ExtractRegexNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Regex" })
+], ExtractRegexNode.prototype, "regex", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Dotall" })
+], ExtractRegexNode.prototype, "dotall", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Ignorecase" })
+], ExtractRegexNode.prototype, "ignorecase", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Multiline" })
+], ExtractRegexNode.prototype, "multiline", void 0);
+export class FindAllRegexNode extends BaseNode {
+    static nodeType = "nodetool.text.FindAllRegex";
+    static title = "Find All Regex Matches";
+    static description = "Finds all regex matches in text as separate substrings.\n    text, regex, find";
+    static metadataOutputTypes = {
+        output: "list[str]"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const pattern = String(this.regex ?? this.regex ?? "");
+        const flags = `${flagsFromOpts({
+            dotall: this.dotall ?? this.dotall,
+            ignorecase: this.ignorecase ?? this.ignorecase,
+            multiline: this.multiline ?? this.multiline
+        })}g`;
+        const matches = [...text.matchAll(new RegExp(pattern, flags))].map((m) => m[0]);
+        return { output: matches };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], FindAllRegexNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Regex" })
+], FindAllRegexNode.prototype, "regex", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Dotall" })
+], FindAllRegexNode.prototype, "dotall", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Ignorecase" })
+], FindAllRegexNode.prototype, "ignorecase", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Multiline" })
+], FindAllRegexNode.prototype, "multiline", void 0);
+export class TextParseJSONNode extends BaseNode {
+    static nodeType = "nodetool.text.ParseJSON";
+    static title = "Parse JSON String";
+    static description = "Parses a JSON string into a Python object.\n    json, parse, convert";
+    static metadataOutputTypes = {
+        output: "any"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        return { output: JSON.parse(text) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "JSON string" })
+], TextParseJSONNode.prototype, "text", void 0);
+function jsonPathFind(path, root) {
+    if (!path.startsWith("$")) {
+        return [];
+    }
+    const tokens = path
+        .replace(/^\$\./, "")
+        .replace(/\[(\d+)\]/g, ".$1")
+        .split(".")
+        .filter(Boolean);
+    let current = [root];
+    for (const token of tokens) {
+        const next = [];
+        for (const value of current) {
+            if (token === "*") {
+                if (Array.isArray(value)) {
+                    next.push(...value);
+                }
+                else if (value && typeof value === "object") {
+                    next.push(...Object.values(value));
+                }
+                continue;
+            }
+            if (Array.isArray(value)) {
+                const idx = Number(token);
+                if (Number.isInteger(idx) && idx >= 0 && idx < value.length) {
+                    next.push(value[idx]);
+                }
+                continue;
+            }
+            if (value && typeof value === "object" && token in value) {
+                next.push(value[token]);
+            }
+        }
+        current = next;
+        if (current.length === 0) {
+            break;
+        }
+    }
+    return current;
+}
+export class ExtractJSONNode extends BaseNode {
+    static nodeType = "nodetool.text.ExtractJSON";
+    static title = "Extract JSON";
+    static description = "Extracts data from JSON using JSONPath expressions.\n    json, extract, jsonpath";
+    static metadataOutputTypes = {
+        output: "any"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const jsonPath = String(this.json_path ?? this.json_path ?? "$.*");
+        const findAll = Boolean(this.find_all ?? this.find_all ?? false);
+        const parsed = JSON.parse(text);
+        const matches = jsonPathFind(jsonPath, parsed);
+        if (findAll) {
+            return { output: matches };
+        }
+        if (matches.length === 0) {
+            throw new Error("JSONPath did not match any value");
+        }
+        return { output: matches[0] };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "JSON Text" })
+], ExtractJSONNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "$.*", title: "JSONPath Expression" })
+], ExtractJSONNode.prototype, "json_path", void 0);
+__decorate([
+    prop({ type: "bool", default: false, title: "Find All" })
+], ExtractJSONNode.prototype, "find_all", void 0);
+export class RegexMatchNode extends BaseNode {
+    static nodeType = "nodetool.text.RegexMatch";
+    static title = "Find Regex Matches";
+    static description = "Find all matches of a regex pattern in text.\n    regex, search, pattern, match\n\n    Use cases:\n    - Extract specific patterns from text\n    - Validate text against patterns\n    - Find all occurrences of a pattern";
+    static metadataOutputTypes = {
+        output: "list[str]"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const pattern = String(this.pattern ?? this.pattern ?? "");
+        const group = this.group ?? this.group;
+        if (group === null || group === undefined) {
+            return {
+                output: [...text.matchAll(new RegExp(pattern, "g"))].map((m) => m[0])
+            };
+        }
+        const groupIndex = Number(group);
+        const out = [...text.matchAll(new RegExp(pattern, "g"))].map((m) => m[groupIndex]);
+        return { output: out.filter((v) => v !== undefined) };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Text",
+        description: "Text to search in"
+    })
+], RegexMatchNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Pattern",
+        description: "Regular expression pattern"
+    })
+], RegexMatchNode.prototype, "pattern", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Group",
+        description: "Capture group to extract (0 for full match)"
+    })
+], RegexMatchNode.prototype, "group", void 0);
+export class RegexReplaceNode extends BaseNode {
+    static nodeType = "nodetool.text.RegexReplace";
+    static title = "Replace with Regex";
+    static description = "Replace text matching a regex pattern.\n    regex, replace, substitute\n\n    Use cases:\n    - Clean or standardize text\n    - Remove unwanted patterns\n    - Transform text formats";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        let text = String(this.text ?? this.text ?? "");
+        const pattern = String(this.pattern ?? this.pattern ?? "");
+        const replacement = String(this.replacement ?? this.replacement ?? "");
+        const count = Number(this.count ?? this.count ?? 0);
+        if (count <= 0) {
+            return { output: text.replace(new RegExp(pattern, "g"), replacement) };
+        }
+        const regex = new RegExp(pattern, "g");
+        let replaced = 0;
+        text = text.replace(regex, (match) => {
+            if (replaced >= count) {
+                return match;
+            }
+            replaced += 1;
+            return replacement;
+        });
+        return { output: text };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Text",
+        description: "Text to perform replacements on"
+    })
+], RegexReplaceNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Pattern",
+        description: "Regular expression pattern"
+    })
+], RegexReplaceNode.prototype, "pattern", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Replacement",
+        description: "Replacement text"
+    })
+], RegexReplaceNode.prototype, "replacement", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Count",
+        description: "Maximum replacements (0 for unlimited)"
+    })
+], RegexReplaceNode.prototype, "count", void 0);
+export class RegexSplitNode extends BaseNode {
+    static nodeType = "nodetool.text.RegexSplit";
+    static title = "Split with Regex";
+    static description = "Split text using a regex pattern as delimiter.\n    regex, split, tokenize\n\n    Use cases:\n    - Parse structured text\n    - Extract fields from formatted strings\n    - Tokenize text";
+    static metadataOutputTypes = {
+        output: "list[str]"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const pattern = String(this.pattern ?? this.pattern ?? "");
+        const maxsplit = Number(this.maxsplit ?? this.maxsplit ?? 0);
+        if (maxsplit <= 0) {
+            return { output: text.split(new RegExp(pattern)) };
+        }
+        const result = [];
+        let remaining = text;
+        let count = 0;
+        const re = new RegExp(pattern);
+        let match;
+        while (count < maxsplit && (match = re.exec(remaining)) !== null) {
+            result.push(remaining.slice(0, match.index));
+            remaining = remaining.slice(match.index + match[0].length);
+            re.lastIndex = 0;
+            count++;
+        }
+        result.push(remaining);
+        return { output: result };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Text",
+        description: "Text to split"
+    })
+], RegexSplitNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Pattern",
+        description: "Regular expression pattern to split on"
+    })
+], RegexSplitNode.prototype, "pattern", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Maxsplit",
+        description: "Maximum number of splits (0 for unlimited)"
+    })
+], RegexSplitNode.prototype, "maxsplit", void 0);
+export class RegexValidateNode extends BaseNode {
+    static nodeType = "nodetool.text.RegexValidate";
+    static title = "Validate with Regex";
+    static description = "Check if text matches a regex pattern.\n    regex, validate, check\n\n    Use cases:\n    - Validate input formats (email, phone, etc)\n    - Check text structure\n    - Filter text based on patterns";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const pattern = String(this.pattern ?? this.pattern ?? "");
+        // Anchor at start to match Python's re.match() behavior
+        const anchored = pattern.startsWith("^") ? pattern : `^(?:${pattern})`;
+        return { output: new RegExp(anchored).test(text) };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Text",
+        description: "Text to validate"
+    })
+], RegexValidateNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Pattern",
+        description: "Regular expression pattern"
+    })
+], RegexValidateNode.prototype, "pattern", void 0);
+export class CompareTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Compare";
+    static title = "Compare Text";
+    static description = "Compares two text values and reports ordering.\n    text, compare, equality, sort, equals, =\n\n    Use cases:\n    - Checking if two strings are identical before branching\n    - Determining lexical order for sorting or deduplication\n    - Normalizing casing/spacing before compares";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const textA = String(this.text_a ?? this.text_a ?? "");
+        const textB = String(this.text_b ?? this.text_b ?? "");
+        const caseSensitive = Boolean(this.case_sensitive ?? this.case_sensitive ?? true);
+        const trimWhitespace = Boolean(this.trim_whitespace ?? this.trim_whitespace ?? false);
+        const normalize = (value) => {
+            const trimmed = trimWhitespace ? value.trim() : value;
+            return caseSensitive ? trimmed : trimmed.toLowerCase();
+        };
+        const left = normalize(textA);
+        const right = normalize(textB);
+        if (left < right) {
+            return { output: "less" };
+        }
+        if (left > right) {
+            return { output: "greater" };
+        }
+        return { output: "equal" };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "First Text" })
+], CompareTextNode.prototype, "text_a", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Second Text" })
+], CompareTextNode.prototype, "text_b", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: "Case Sensitive",
+        description: "Compare without lowercasing"
+    })
+], CompareTextNode.prototype, "case_sensitive", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Trim Whitespace",
+        description: "Strip leading/trailing whitespace before comparing"
+    })
+], CompareTextNode.prototype, "trim_whitespace", void 0);
+export class EqualsTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Equals";
+    static title = "Equals";
+    static description = "Checks if two text inputs are equal.\n    text, compare, equals, match, =";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const cmp = new CompareTextNode();
+        cmp.assign(this.serialize());
+        const result = await cmp.process();
+        return { output: result.output === "equal" };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "First Text" })
+], EqualsTextNode.prototype, "text_a", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Second Text" })
+], EqualsTextNode.prototype, "text_b", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: "Case Sensitive",
+        description: "Disable lowercasing before compare"
+    })
+], EqualsTextNode.prototype, "case_sensitive", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Trim Whitespace",
+        description: "Strip leading/trailing whitespace prior to comparison"
+    })
+], EqualsTextNode.prototype, "trim_whitespace", void 0);
+export class ToUppercaseNode extends BaseNode {
+    static nodeType = "nodetool.text.ToUppercase";
+    static title = "To Uppercase";
+    static description = "Converts text to uppercase.\n    text, transform, uppercase, format";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        return { output: String(this.text ?? this.text ?? "").toUpperCase() };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], ToUppercaseNode.prototype, "text", void 0);
+export class ToLowercaseNode extends BaseNode {
+    static nodeType = "nodetool.text.ToLowercase";
+    static title = "To Lowercase";
+    static description = "Converts text to lowercase.\n    text, transform, lowercase, format";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        return { output: String(this.text ?? this.text ?? "").toLowerCase() };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], ToLowercaseNode.prototype, "text", void 0);
+export class ToTitlecaseNode extends BaseNode {
+    static nodeType = "nodetool.text.ToTitlecase";
+    static title = "To Title Case";
+    static description = "Converts text to title case.\n    text, transform, titlecase, format\n\n    Use cases:\n    - Cleaning user provided titles before display\n    - Normalizing headings in generated documents\n    - Making list entries easier to scan";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        return { output: toTitleCase(String(this.text ?? this.text ?? "")) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], ToTitlecaseNode.prototype, "text", void 0);
+export class CapitalizeTextNode extends BaseNode {
+    static nodeType = "nodetool.text.CapitalizeText";
+    static title = "Capitalize Text";
+    static description = "Capitalizes only the first character.\n    text, transform, capitalize, format\n\n    Use cases:\n    - Formatting short labels or sentences\n    - Cleaning up LLM output before UI rendering\n    - Quickly fixing lowercase starts after concatenation";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        if (!text) {
+            return { output: "" };
+        }
+        return {
+            output: text.charAt(0).toUpperCase() + text.slice(1).toLowerCase()
+        };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], CapitalizeTextNode.prototype, "text", void 0);
+export class SliceTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Slice";
+    static title = "Slice Text";
+    static description = "Slices text using Python's slice notation (start:stop:step).\n    text, slice, substring\n\n    Use cases:\n    - Extracting specific portions of text with flexible indexing\n    - Reversing text using negative step\n    - Taking every nth character with step parameter\n\n    Examples:\n    - start=0, stop=5: first 5 characters\n    - start=-5: last 5 characters\n    - step=2: every second character\n    - step=-1: reverse the text";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const start = Number(this.start ?? this.start ?? 0);
+        const stop = Number(this.stop ?? this.stop ?? 0);
+        const step = Number(this.step ?? this.step ?? 1);
+        if (step === 0) {
+            throw new Error("slice step cannot be zero");
+        }
+        if (step === 1) {
+            const effectiveStop = stop === 0 ? undefined : stop;
+            return { output: text.slice(start, effectiveStop) };
+        }
+        const chars = [...text];
+        const result = [];
+        const len = chars.length;
+        const normStart = start < 0 ? len + start : start;
+        const effectiveStop = stop === 0 ? len : stop;
+        const normStop = effectiveStop < 0 ? len + effectiveStop : effectiveStop;
+        if (step > 0) {
+            for (let i = Math.max(0, normStart); i < Math.min(len, normStop); i += step) {
+                result.push(chars[i]);
+            }
+        }
+        else {
+            for (let i = Math.min(len - 1, normStart); i > Math.max(-1, normStop); i += step) {
+                if (i >= 0 && i < len) {
+                    result.push(chars[i]);
+                }
+            }
+        }
+        return { output: result.join("") };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], SliceTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Start Index" })
+], SliceTextNode.prototype, "start", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Stop Index" })
+], SliceTextNode.prototype, "stop", void 0);
+__decorate([
+    prop({ type: "int", default: 1, title: "Step" })
+], SliceTextNode.prototype, "step", void 0);
+export class StartsWithTextNode extends BaseNode {
+    static nodeType = "nodetool.text.StartsWith";
+    static title = "Starts With";
+    static description = "Checks if text starts with a specified prefix.\n    text, check, prefix, compare, validate, substring, string\n\n    Use cases:\n    - Validating string prefixes\n    - Filtering text based on starting content\n    - Checking file name patterns";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const prefix = String(this.prefix ?? this.prefix ?? "");
+        return { output: text.startsWith(prefix) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], StartsWithTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Prefix" })
+], StartsWithTextNode.prototype, "prefix", void 0);
+export class EndsWithTextNode extends BaseNode {
+    static nodeType = "nodetool.text.EndsWith";
+    static title = "Ends With";
+    static description = "Checks if text ends with a specified suffix.\n    text, check, suffix, compare, validate, substring, string\n\n    Use cases:\n    - Validating file extensions\n    - Checking string endings\n    - Filtering text based on ending content";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const suffix = String(this.suffix ?? this.suffix ?? "");
+        return { output: text.endsWith(suffix) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], EndsWithTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Suffix" })
+], EndsWithTextNode.prototype, "suffix", void 0);
+export class ContainsTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Contains";
+    static title = "Contains Text";
+    static description = "Checks if text contains a specified substring.\n    text, compare, validate, substring, string";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const substring = String(this.substring ?? this.substring ?? "");
+        const searchValues = Array.isArray(this.search_values ?? this.search_values)
+            ? (this.search_values ?? this.search_values).map((v) => String(v))
+            : [];
+        const caseSensitive = Boolean(this.case_sensitive ?? this.case_sensitive ?? true);
+        const matchMode = String(this.match_mode ?? this.match_mode ?? "any");
+        const targets = searchValues.length > 0 ? searchValues : substring ? [substring] : [];
+        if (targets.length === 0) {
+            return { output: false };
+        }
+        const haystack = caseSensitive ? text : text.toLowerCase();
+        const needles = caseSensitive
+            ? targets
+            : targets.map((n) => n.toLowerCase());
+        if (matchMode === "all") {
+            return { output: needles.every((needle) => haystack.includes(needle)) };
+        }
+        if (matchMode === "none") {
+            return { output: needles.every((needle) => !haystack.includes(needle)) };
+        }
+        return { output: needles.some((needle) => haystack.includes(needle)) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], ContainsTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Substring" })
+], ContainsTextNode.prototype, "substring", void 0);
+__decorate([
+    prop({
+        type: "list[str]",
+        default: [],
+        title: "Search Values",
+        description: "Optional list of additional substrings to check"
+    })
+], ContainsTextNode.prototype, "search_values", void 0);
+__decorate([
+    prop({ type: "bool", default: true, title: "Case Sensitive" })
+], ContainsTextNode.prototype, "case_sensitive", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "any",
+        title: "Match Mode",
+        description: "ANY requires one match, ALL needs every value, NONE ensures none",
+        values: ["any", "all", "none"]
+    })
+], ContainsTextNode.prototype, "match_mode", void 0);
+export class TrimWhitespaceNode extends BaseNode {
+    static nodeType = "nodetool.text.TrimWhitespace";
+    static title = "Trim Whitespace";
+    static description = "Trims whitespace from the start and/or end of text.\n    text, whitespace, clean, remove";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const trimStart = Boolean(this.trim_start ?? this.trim_start ?? true);
+        const trimEnd = Boolean(this.trim_end ?? this.trim_end ?? true);
+        if (trimStart && trimEnd) {
+            return { output: text.trim() };
+        }
+        if (trimStart) {
+            return { output: text.replace(/^\s+/, "") };
+        }
+        if (trimEnd) {
+            return { output: text.replace(/\s+$/, "") };
+        }
+        return { output: text };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], TrimWhitespaceNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "bool", default: true, title: "Trim Start" })
+], TrimWhitespaceNode.prototype, "trim_start", void 0);
+__decorate([
+    prop({ type: "bool", default: true, title: "Trim End" })
+], TrimWhitespaceNode.prototype, "trim_end", void 0);
+export class CollapseWhitespaceNode extends BaseNode {
+    static nodeType = "nodetool.text.CollapseWhitespace";
+    static title = "Collapse Whitespace";
+    static description = "Collapses consecutive whitespace into single separators.\n    text, whitespace, normalize, clean, remove";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const preserveNewlines = Boolean(this.preserve_newlines ?? this.preserve_newlines ?? false);
+        const replacement = String(this.replacement ?? this.replacement ?? " ");
+        const trimEdges = Boolean(this.trim_edges ?? this.trim_edges ?? true);
+        const value = trimEdges ? text.trim() : text;
+        if (preserveNewlines) {
+            return { output: value.replace(/[^\S\r\n]+/g, replacement) };
+        }
+        return { output: value.replace(/\s+/g, replacement) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], CollapseWhitespaceNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Preserve Newlines",
+        description: "Keep newline characters instead of replacing them"
+    })
+], CollapseWhitespaceNode.prototype, "preserve_newlines", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: " ",
+        title: "Replacement",
+        description: "String used to replace whitespace runs"
+    })
+], CollapseWhitespaceNode.prototype, "replacement", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: "Trim Edges",
+        description: "Strip whitespace before collapsing"
+    })
+], CollapseWhitespaceNode.prototype, "trim_edges", void 0);
+export class IsEmptyTextNode extends BaseNode {
+    static nodeType = "nodetool.text.IsEmpty";
+    static title = "Is Empty";
+    static description = "Checks if text is empty or contains only whitespace.\n    text, check, empty, compare, validate, whitespace, string";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const trimWhitespace = Boolean(this.trim_whitespace ?? this.trim_whitespace ?? true);
+        return { output: (trimWhitespace ? text.trim() : text).length === 0 };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], IsEmptyTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "bool", default: true, title: "Trim Whitespace" })
+], IsEmptyTextNode.prototype, "trim_whitespace", void 0);
+export class RemovePunctuationNode extends BaseNode {
+    static nodeType = "nodetool.text.RemovePunctuation";
+    static title = "Remove Punctuation";
+    static description = "Removes punctuation characters from text.\n    text, cleanup, punctuation, normalize";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const replacement = String(this.replacement ?? this.replacement ?? "");
+        const punctuation = String(this.punctuation ??
+            this.punctuation ??
+            `!"#$%&'()*+,\\-./:;<=>?@[\\]^_{|}~`);
+        const escaped = punctuation.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return {
+            output: text.replace(new RegExp(`[${escaped}]`, "g"), replacement)
+        };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], RemovePunctuationNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Replacement",
+        description: "String to insert where punctuation was removed"
+    })
+], RemovePunctuationNode.prototype, "replacement", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+        title: "Punctuation Characters",
+        description: "Characters that should be removed or replaced"
+    })
+], RemovePunctuationNode.prototype, "punctuation", void 0);
+export class StripAccentsNode extends BaseNode {
+    static nodeType = "nodetool.text.StripAccents";
+    static title = "Strip Accents";
+    static description = "Removes accent marks while keeping base characters.\n    text, cleanup, accents, normalize";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const preserveNonAscii = Boolean(this.preserve_non_ascii ?? this.preserve_non_ascii ?? true);
+        const normalized = text.normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
+        if (preserveNonAscii) {
+            return { output: normalized };
+        }
+        // eslint-disable-next-line no-control-regex
+        return { output: normalized.replace(/[^\x00-\x7F]/g, "") };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], StripAccentsNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: "Preserve Non-ASCII",
+        description: "Keep non-ASCII characters that are not accents"
+    })
+], StripAccentsNode.prototype, "preserve_non_ascii", void 0);
+export class SlugifyNode extends BaseNode {
+    static nodeType = "nodetool.text.Slugify";
+    static title = "Slugify";
+    static description = "Converts text into a slug suitable for URLs or IDs.\n    text, slug, normalize, id";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const separator = String(this.separator ?? this.separator ?? "-");
+        const lowercase = Boolean(this.lowercase ?? this.lowercase ?? true);
+        const allowUnicode = Boolean(this.allow_unicode ?? this.allow_unicode ?? false);
+        let value = text.normalize("NFKD");
+        if (!allowUnicode) {
+            // eslint-disable-next-line no-control-regex
+            value = value.replace(/[^\x00-\x7F]/g, "");
+        }
+        value = value.replace(/[^\w\s-]/g, "");
+        value = value.replace(/[\s_-]+/g, separator).replace(/^[-_]+|[-_]+$/g, "");
+        if (lowercase) {
+            value = value.toLowerCase();
+        }
+        return { output: value };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], SlugifyNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "-", title: "Separator" })
+], SlugifyNode.prototype, "separator", void 0);
+__decorate([
+    prop({ type: "bool", default: true, title: "Lowercase" })
+], SlugifyNode.prototype, "lowercase", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Allow Unicode",
+        description: "Keep unicode letters instead of converting to ASCII"
+    })
+], SlugifyNode.prototype, "allow_unicode", void 0);
+export class HasLengthTextNode extends BaseNode {
+    static nodeType = "nodetool.text.HasLength";
+    static title = "Check Length";
+    static description = "Checks if text length meets specified conditions.\n    text, check, length, compare, validate, whitespace, string";
+    static metadataOutputTypes = {
+        output: "bool"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const minLength = Number(this.min_length ?? this.min_length ?? 0);
+        const maxLength = Number(this.max_length ?? this.max_length ?? 0);
+        const exactLength = Number(this.exact_length ?? this.exact_length ?? 0);
+        const length = text.length;
+        if (exactLength !== null) {
+            return { output: length === exactLength };
+        }
+        if (minLength !== null && length < minLength) {
+            return { output: false };
+        }
+        if (maxLength !== null && length > maxLength) {
+            return { output: false };
+        }
+        return { output: true };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], HasLengthTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Minimum Length" })
+], HasLengthTextNode.prototype, "min_length", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Maximum Length" })
+], HasLengthTextNode.prototype, "max_length", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Exact Length" })
+], HasLengthTextNode.prototype, "exact_length", void 0);
+export class TruncateTextNode extends BaseNode {
+    static nodeType = "nodetool.text.TruncateText";
+    static title = "Truncate Text";
+    static description = "Truncates text to a maximum length.\n    text, truncate, length, clip";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const maxLength = Number(this.max_length ?? this.max_length ?? 100);
+        const ellipsis = String(this.ellipsis ?? this.ellipsis ?? "");
+        if (maxLength <= 0) {
+            return { output: ellipsis || "" };
+        }
+        if (text.length <= maxLength) {
+            return { output: text };
+        }
+        if (ellipsis && ellipsis.length < maxLength) {
+            const cut = maxLength - ellipsis.length;
+            return { output: `${text.slice(0, cut)}${ellipsis}` };
+        }
+        return { output: text.slice(0, maxLength) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], TruncateTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "int", default: 100, title: "Max Length", min: 0 })
+], TruncateTextNode.prototype, "max_length", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Ellipsis",
+        description: "Optional suffix appended when truncation occurs"
+    })
+], TruncateTextNode.prototype, "ellipsis", void 0);
+export class PadTextNode extends BaseNode {
+    static nodeType = "nodetool.text.PadText";
+    static title = "Pad Text";
+    static description = "Pads text to a target length.\n    text, pad, length, format";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const length = Number(this.length ?? this.length ?? 0);
+        const padCharacter = String(this.pad_character ?? this.pad_character ?? " ");
+        const direction = String(this.direction ?? this.direction ?? "right");
+        if (padCharacter.length !== 1) {
+            throw new Error("pad_character must be a single character");
+        }
+        if (length <= text.length) {
+            return { output: text };
+        }
+        const needed = length - text.length;
+        if (direction === "left") {
+            return { output: padCharacter.repeat(needed) + text };
+        }
+        if (direction === "both") {
+            const left = Math.floor(needed / 2);
+            const right = needed - left;
+            return {
+                output: `${padCharacter.repeat(left)}${text}${padCharacter.repeat(right)}`
+            };
+        }
+        return { output: text + padCharacter.repeat(needed) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], PadTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "int", default: 0, title: "Target Length", min: 0 })
+], PadTextNode.prototype, "length", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: " ",
+        title: "Pad Character",
+        description: "Single character to use for padding"
+    })
+], PadTextNode.prototype, "pad_character", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "right",
+        title: "Direction",
+        description: "Where padding should be applied",
+        values: ["left", "right", "both"]
+    })
+], PadTextNode.prototype, "direction", void 0);
+export class LengthTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Length";
+    static title = "Measure Length";
+    static description = "Measures text length as characters, words, or lines.\n    text, analyze, length, count";
+    static metadataOutputTypes = {
+        output: "int"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const measure = String(this.measure ?? this.measure ?? "characters");
+        const trimWhitespace = Boolean(this.trim_whitespace ?? this.trim_whitespace ?? false);
+        const value = trimWhitespace ? text.trim() : text;
+        if (measure === "words") {
+            return { output: value.split(/\s+/).filter(Boolean).length };
+        }
+        if (measure === "lines") {
+            if (!value) {
+                return { output: 0 };
+            }
+            return {
+                output: value.split(/\r?\n/).filter((line) => line || !trimWhitespace)
+                    .length
+            };
+        }
+        return { output: value.length };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], LengthTextNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "characters",
+        title: "Measure",
+        description: "Choose whether to count characters, words, or lines",
+        values: ["characters", "words", "lines"]
+    })
+], LengthTextNode.prototype, "measure", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Trim Whitespace",
+        description: "Strip whitespace before counting"
+    })
+], LengthTextNode.prototype, "trim_whitespace", void 0);
+export class IndexOfTextNode extends BaseNode {
+    static nodeType = "nodetool.text.IndexOf";
+    static title = "Index Of";
+    static description = "Finds the position of a substring in text.\n    text, search, find, substring";
+    static metadataOutputTypes = {
+        output: "int"
+    };
+    async process() {
+        let haystack = String(this.text ?? this.text ?? "");
+        let needle = String(this.substring ?? this.substring ?? "");
+        const caseSensitive = Boolean(this.case_sensitive ?? this.case_sensitive ?? true);
+        const startIndex = Number(this.start_index ?? this.start_index ?? 0);
+        const endIndex = Number(this.end_index ?? this.end_index ?? 0);
+        const searchFromEnd = Boolean(this.search_from_end ?? this.search_from_end ?? false);
+        if (!caseSensitive) {
+            haystack = haystack.toLowerCase();
+            needle = needle.toLowerCase();
+        }
+        const effectiveEnd = endIndex > 0 ? endIndex : haystack.length;
+        if (searchFromEnd) {
+            // lastIndexOf's second arg is the position to search backward from.
+            // We want to find the last occurrence within [startIndex, effectiveEnd).
+            // Search backward from effectiveEnd - 1, then verify >= startIndex.
+            const idx = haystack.lastIndexOf(needle, effectiveEnd - 1);
+            return { output: idx >= startIndex ? idx : -1 };
+        }
+        const searchRegion = haystack.slice(startIndex, effectiveEnd);
+        const idx = searchRegion.indexOf(needle);
+        return { output: idx < 0 ? -1 : startIndex + idx };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], IndexOfTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Substring" })
+], IndexOfTextNode.prototype, "substring", void 0);
+__decorate([
+    prop({ type: "bool", default: true, title: "Case Sensitive" })
+], IndexOfTextNode.prototype, "case_sensitive", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "Start Index",
+        description: "Index to begin the search from",
+        min: 0
+    })
+], IndexOfTextNode.prototype, "start_index", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 0,
+        title: "End Index",
+        description: "Optional exclusive end index for the search"
+    })
+], IndexOfTextNode.prototype, "end_index", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Search From End",
+        description: "Use the last occurrence instead of the first"
+    })
+], IndexOfTextNode.prototype, "search_from_end", void 0);
+export class SurroundWithTextNode extends BaseNode {
+    static nodeType = "nodetool.text.SurroundWith";
+    static title = "Surround With";
+    static description = "Wraps text with the provided prefix and suffix.\n    text, format, surround, decorate";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const prefix = String(this.prefix ?? this.prefix ?? "");
+        const suffix = String(this.suffix ?? this.suffix ?? "");
+        const skipIfWrapped = Boolean(this.skip_if_wrapped ?? this.skip_if_wrapped ?? true);
+        if (skipIfWrapped && text.startsWith(prefix) && text.endsWith(suffix)) {
+            return { output: text };
+        }
+        return { output: `${prefix}${text}${suffix}` };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], SurroundWithTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Prefix" })
+], SurroundWithTextNode.prototype, "prefix", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Suffix" })
+], SurroundWithTextNode.prototype, "suffix", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: "Skip If Already Wrapped",
+        description: "Do not add duplicates if the text is already wrapped"
+    })
+], SurroundWithTextNode.prototype, "skip_if_wrapped", void 0);
+export class CountTokensNode extends BaseNode {
+    static nodeType = "nodetool.text.CountTokens";
+    static title = "Count Tokens";
+    static description = "Counts the number of tokens in text using tiktoken.\n    text, tokens, count, encoding";
+    static metadataOutputTypes = {
+        output: "int"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        if (!text.trim()) {
+            return { output: 0 };
+        }
+        const tokens = text.match(/[A-Za-z0-9_]+|[^\s]/g) ?? [];
+        return { output: tokens.length };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], CountTokensNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "cl100k_base",
+        title: "Encoding",
+        description: "The tiktoken encoding to use for token counting",
+        values: ["cl100k_base", "p50k_base", "r50k_base"]
+    })
+], CountTokensNode.prototype, "encoding", void 0);
+export class HtmlToTextNode extends BaseNode {
+    static nodeType = "nodetool.text.HtmlToText";
+    static title = "HTML to Text";
+    static description = "Converts HTML content to plain text using html2text.\n    html, convert, text, parse, extract";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const html = String(this.html ?? this.html ?? "");
+        const baseUrl = String(this.base_url ?? this.base_url ?? "");
+        const bodyWidth = Number(this.body_width ?? this.body_width ?? 1000);
+        let text = html;
+        // Remove scripts and styles
+        text = text.replace(/<script[\s\S]*?<\/script>/gi, "");
+        text = text.replace(/<style[\s\S]*?<\/style>/gi, "");
+        // Convert headers to markdown-style
+        text = text.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_m, level, content) => {
+            const hashes = "#".repeat(Number(level));
+            const clean = content.replace(/<[^>]+>/g, "").trim();
+            return `\n\n${hashes} ${clean}\n\n`;
+        });
+        // Convert links: <a href="url">text</a> -> text (url)
+        text = text.replace(/<a\s+[^>]*href=["']([^"']*)["'][^>]*>([\s\S]*?)<\/a>/gi, (_m, href, linkText) => {
+            const clean = linkText.replace(/<[^>]+>/g, "").trim();
+            let resolvedUrl = href;
+            if (baseUrl && href && !href.match(/^https?:\/\//)) {
+                const base = baseUrl.endsWith("/") ? baseUrl : baseUrl + "/";
+                resolvedUrl = href.startsWith("/") ? baseUrl.replace(/\/$/, "") + href : base + href;
+            }
+            if (baseUrl && resolvedUrl && resolvedUrl !== clean) {
+                return `${clean} (${resolvedUrl})`;
+            }
+            return clean;
+        });
+        // Convert unordered lists
+        text = text.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (_m, content) => {
+            return "\n" + content.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_li, item) => {
+                return `  * ${item.replace(/<[^>]+>/g, "").trim()}\n`;
+            }) + "\n";
+        });
+        // Convert ordered lists
+        text = text.replace(/<ol[^>]*>([\s\S]*?)<\/ol>/gi, (_m, content) => {
+            let idx = 0;
+            return "\n" + content.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_li, item) => {
+                idx++;
+                return `  ${idx}. ${item.replace(/<[^>]+>/g, "").trim()}\n`;
+            }) + "\n";
+        });
+        // Convert block elements to double newlines
+        text = text.replace(/<\/(p|div|section|article)>/gi, "\n\n");
+        text = text.replace(/<(p|div|section|article)[^>]*>/gi, "");
+        // Convert <br> to newlines
+        text = text.replace(/<br\s*\/?>/gi, "\n");
+        // Remove remaining tags
+        text = text.replace(/<[^>]+>/g, "");
+        // Decode HTML entities
+        text = text
+            .replace(/&nbsp;/g, " ")
+            .replace(/&amp;/g, "&")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&#39;/g, "'")
+            .replace(/&apos;/g, "'")
+            .replace(/&quot;/g, '"')
+            .replace(/&#(\d+);/g, (_m, code) => String.fromCharCode(Number(code)))
+            .replace(/&#x([0-9a-fA-F]+);/g, (_m, code) => String.fromCharCode(parseInt(code, 16)));
+        // Normalize whitespace: collapse multiple blank lines
+        text = text.replace(/\n{3,}/g, "\n\n");
+        // Apply body_width wrapping
+        if (bodyWidth > 0) {
+            const lines = text.split("\n");
+            const wrapped = [];
+            for (const line of lines) {
+                if (line.length <= bodyWidth) {
+                    wrapped.push(line);
+                }
+                else {
+                    let remaining = line;
+                    while (remaining.length > bodyWidth) {
+                        let breakAt = remaining.lastIndexOf(" ", bodyWidth);
+                        if (breakAt <= 0)
+                            breakAt = bodyWidth;
+                        wrapped.push(remaining.slice(0, breakAt));
+                        remaining = remaining.slice(breakAt).trimStart();
+                    }
+                    if (remaining)
+                        wrapped.push(remaining);
+                }
+            }
+            text = wrapped.join("\n");
+        }
+        return { output: text.trim() };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "HTML",
+        description: "HTML content to convert"
+    })
+], HtmlToTextNode.prototype, "html", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Base URL",
+        description: "Base URL for resolving relative links"
+    })
+], HtmlToTextNode.prototype, "base_url", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 1000,
+        title: "Body Width",
+        description: "Width for text wrapping"
+    })
+], HtmlToTextNode.prototype, "body_width", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: "Ignore Images",
+        description: "Whether to ignore image tags"
+    })
+], HtmlToTextNode.prototype, "ignore_images", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: true,
+        title: "Ignore Mailto Links",
+        description: "Whether to ignore mailto links"
+    })
+], HtmlToTextNode.prototype, "ignore_mailto_links", void 0);
+function seededEmbedding(input, dims = 64) {
+    const out = new Array(dims).fill(0);
+    for (let i = 0; i < input.length; i++) {
+        const code = input.charCodeAt(i);
+        const idx = i % dims;
+        out[idx] += (code % 97) / 97;
+    }
+    const norm = Math.sqrt(out.reduce((a, b) => a + b * b, 0)) || 1;
+    return out.map((v) => v / norm);
+}
+export class AutomaticSpeechRecognitionNode extends BaseNode {
+    static nodeType = "nodetool.text.AutomaticSpeechRecognition";
+    static title = "Automatic Speech Recognition";
+    static description = "Transcribe audio to text using automatic speech recognition models.\n    audio, speech, recognition, transcription, ASR, whisper";
+    static metadataOutputTypes = {
+        text: "str"
+    };
+    static exposeAsTool = true;
+    async process(context) {
+        const { providerId, modelId } = modelConfig(this.serialize());
+        const audio = (this.audio ?? this.audio ?? {});
+        let bytes = new Uint8Array();
+        if (typeof audio.data === "string") {
+            bytes = Uint8Array.from(Buffer.from(audio.data, "base64"));
+        }
+        else if (audio.data instanceof Uint8Array) {
+            bytes = new Uint8Array(audio.data);
+        }
+        else if (typeof audio.uri === "string" && audio.uri) {
+            if (context?.storage) {
+                const stored = await context.storage.retrieve(audio.uri);
+                if (stored !== null)
+                    bytes = new Uint8Array(stored);
+            }
+            if (bytes.length === 0 && audio.uri.startsWith("file://")) {
+                bytes = new Uint8Array(await fs.readFile(audio.uri.slice("file://".length)));
+            }
+        }
+        if (context &&
+            typeof context.runProviderPrediction === "function" &&
+            providerId &&
+            modelId &&
+            bytes.length > 0) {
+            const text = (await context.runProviderPrediction({
+                provider: providerId,
+                capability: "automatic_speech_recognition",
+                model: modelId,
+                params: {
+                    audio: bytes,
+                    language: this.language,
+                    prompt: this.prompt,
+                    temperature: this.temperature
+                }
+            }));
+            return { text, output: text };
+        }
+        throw new Error("AutomaticSpeechRecognition requires a provider-backed model and audio input.");
+    }
+}
+__decorate([
+    prop({
+        type: "asr_model",
+        default: {
+            type: "asr_model",
+            provider: "fal_ai",
+            id: "openai/whisper-large-v3",
+            name: "",
+            path: null
+        },
+        title: "Model"
+    })
+], AutomaticSpeechRecognitionNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "audio",
+        default: {
+            type: "audio",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Audio",
+        description: "The audio to transcribe",
+        required: true
+    })
+], AutomaticSpeechRecognitionNode.prototype, "audio", void 0);
+export class EmbeddingTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Embedding";
+    static title = "Embedding";
+    static description = "Generate vector representations of text using any supported embedding provider.\n    Automatically routes to the appropriate backend (OpenAI, Gemini, Mistral).\n    embeddings, similarity, search, clustering, classification, vectors, semantic\n\n    Uses embedding models to create dense vector representations of text.\n    These vectors capture semantic meaning, enabling:\n    - Semantic search\n    - Text clustering\n    - Document classification\n    - Recommendation systems\n    - Anomaly detection\n    - Measuring text similarity and diversity";
+    static metadataOutputTypes = {
+        output: "list"
+    };
+    static basicFields = ["model", "input"];
+    static exposeAsTool = true;
+    async process() {
+        const text = String(this.input ?? this.input ?? "");
+        return { output: seededEmbedding(text) };
+    }
+}
+__decorate([
+    prop({
+        type: "embedding_model",
+        default: {
+            type: "embedding_model",
+            provider: "openai",
+            id: "text-embedding-3-small",
+            name: "Text Embedding 3 Small",
+            dimensions: 0
+        },
+        title: "Model",
+        description: "The embedding model to use"
+    })
+], EmbeddingTextNode.prototype, "model", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Input",
+        description: "The text to embed"
+    })
+], EmbeddingTextNode.prototype, "input", void 0);
+__decorate([
+    prop({
+        type: "int",
+        default: 4096,
+        title: "Chunk Size",
+        description: "Size of text chunks for embedding (used when input exceeds model limits)",
+        min: 1,
+        max: 8192
+    })
+], EmbeddingTextNode.prototype, "chunk_size", void 0);
+export class SaveTextFileNode extends BaseNode {
+    static nodeType = "nodetool.text.SaveTextFile";
+    static title = "Save Text File";
+    static description = "Saves input text to a file in the assets folder.\n    text, save, file";
+    static metadataOutputTypes = {
+        output: "text"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const folder = String(this.folder ?? this.folder ?? "");
+        const name = String(this.name ?? this.name ?? "output.txt");
+        if (!folder) {
+            throw new Error("folder cannot be empty");
+        }
+        await fs.mkdir(folder, { recursive: true });
+        const fsPath = join(folder, name);
+        await fs.writeFile(fsPath, text, "utf-8");
+        // The output `uri` is a portable, URI-style path (forward slashes) so
+        // downstream nodes and the web UI never have to special-case Windows.
+        const uri = fsPath.replace(/\\/g, "/");
+        return { output: { uri, data: text } };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], SaveTextFileNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Folder",
+        description: "Path to the output folder."
+    })
+], SaveTextFileNode.prototype, "folder", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "%Y-%m-%d-%H-%M-%S.txt",
+        title: "Name",
+        description: "\n        Name of the output file.\n        You can use time and date variables to create unique names:\n        %Y - Year\n        %m - Month\n        %d - Day\n        %H - Hour\n        %M - Minute\n        %S - Second\n        "
+    })
+], SaveTextFileNode.prototype, "name", void 0);
+export class SaveTextNode extends BaseNode {
+    static nodeType = "nodetool.text.SaveText";
+    static title = "Save Text";
+    static description = "Saves input text to a file in the assets folder.\n    text, save, file\n\n    Use cases:\n    - Persisting processed text results\n    - Creating text files for downstream nodes or external use\n    - Archiving text data within the workflow";
+    static metadataOutputTypes = {
+        output: "text"
+    };
+    async process() {
+        const text = String(this.text ?? this.text ?? "");
+        const name = String(this.name ?? this.name ?? "output.txt");
+        await fs.writeFile(name, text, "utf-8");
+        return { output: { uri: name, data: text } };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text" })
+], SaveTextNode.prototype, "text", void 0);
+__decorate([
+    prop({
+        type: "folder",
+        default: {
+            type: "folder",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Folder",
+        description: "Name of the output folder."
+    })
+], SaveTextNode.prototype, "folder", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "%Y-%m-%d-%H-%M-%S.txt",
+        title: "Name",
+        description: "\n        Name of the output file.\n        You can use time and date variables to create unique names:\n        %Y - Year\n        %m - Month\n        %d - Day\n        %H - Hour\n        %M - Minute\n        %S - Second\n        "
+    })
+], SaveTextNode.prototype, "name", void 0);
+export class LoadTextFolderNode extends BaseNode {
+    static nodeType = "nodetool.text.LoadTextFolder";
+    static title = "Load Text Folder";
+    static description = "Load all text files from a folder, optionally including subfolders.\n    text, load, folder, files";
+    static metadataOutputTypes = {
+        text: "str",
+        path: "str",
+        texts: "list",
+        paths: "list"
+    };
+    static isStreamingOutput = true;
+    async process() {
+        const allTexts = [];
+        const allPaths = [];
+        for await (const item of this._walkFiles()) {
+            allTexts.push(item.text);
+            allPaths.push(item.path);
+        }
+        return {
+            text: allTexts[0] ?? "",
+            path: allPaths[0] ?? "",
+            texts: allTexts,
+            paths: allPaths
+        };
+    }
+    async *_walkFiles() {
+        const folder = String(this.folder ?? this.folder ?? "");
+        const includeSubdirs = Boolean(this.include_subdirectories ?? this.include_subdirectories ?? false);
+        const extensions = Array.isArray(this.extensions ?? this.extensions)
+            ? (this.extensions ?? this.extensions).map((v) => String(v).toLowerCase())
+            : [".txt"];
+        if (!folder) {
+            throw new Error("folder cannot be empty");
+        }
+        const walk = async function* (dir) {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const full = join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (includeSubdirs) {
+                        yield* walk(full);
+                    }
+                    continue;
+                }
+                yield full;
+            }
+        };
+        for await (const filePath of walk(folder)) {
+            if (!extensions.includes(extname(filePath).toLowerCase())) {
+                continue;
+            }
+            const text = await fs.readFile(filePath, "utf-8");
+            yield { path: filePath, text };
+        }
+    }
+    async *genProcess() {
+        const allTexts = [];
+        const allPaths = [];
+        for await (const item of this._walkFiles()) {
+            allTexts.push(item.text);
+            allPaths.push(item.path);
+            yield { path: item.path, text: item.text };
+        }
+        // Emit collected lists as final output
+        yield { texts: allTexts, paths: allPaths };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Folder",
+        description: "Folder to scan for text files"
+    })
+], LoadTextFolderNode.prototype, "folder", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Include Subdirectories",
+        description: "Include text files in subfolders"
+    })
+], LoadTextFolderNode.prototype, "include_subdirectories", void 0);
+__decorate([
+    prop({
+        type: "list[str]",
+        default: [".txt", ".csv", ".json", ".xml", ".md", ".html", ".pdf"],
+        title: "Extensions",
+        description: "Text file extensions to include"
+    })
+], LoadTextFolderNode.prototype, "extensions", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Pattern",
+        description: "Pattern to match text files"
+    })
+], LoadTextFolderNode.prototype, "pattern", void 0);
+export class LoadTextAssetsNode extends BaseNode {
+    static nodeType = "nodetool.text.LoadTextAssets";
+    static title = "Load Text Assets";
+    static description = "Load text files from an asset folder.\n    load, text, file, import";
+    static metadataOutputTypes = {
+        text: "text",
+        name: "str",
+        texts: "list",
+        names: "list"
+    };
+    static isStreamingOutput = true;
+    async process() {
+        const allTexts = [];
+        const allNames = [];
+        const folder = folderPath(this.folder ?? "");
+        if (!folder) {
+            throw new Error("folder cannot be empty");
+        }
+        const walker = new LoadTextFolderNode();
+        walker.assign({ folder });
+        for await (const item of walker._walkFiles()) {
+            allTexts.push(item.text);
+            allNames.push(item.path);
+        }
+        return {
+            text: allTexts[0] ?? "",
+            name: allNames[0] ?? "",
+            texts: allTexts,
+            names: allNames
+        };
+    }
+    async *genProcess() {
+        const folder = folderPath(this.folder ?? "");
+        if (!folder) {
+            throw new Error("folder cannot be empty");
+        }
+        const allTexts = [];
+        const allNames = [];
+        const walker = new LoadTextFolderNode();
+        walker.assign({ folder });
+        for await (const item of walker._walkFiles()) {
+            allTexts.push(item.text);
+            allNames.push(item.path);
+            yield { text: item.text, name: item.path };
+        }
+        // Emit collected lists as final output
+        yield { texts: allTexts, names: allNames };
+    }
+}
+__decorate([
+    prop({
+        type: "folder",
+        default: {
+            type: "folder",
+            uri: "",
+            asset_id: null,
+            data: null,
+            metadata: null
+        },
+        title: "Folder",
+        description: "The asset folder to load the text files from."
+    })
+], LoadTextAssetsNode.prototype, "folder", void 0);
+export class FilterStringNode extends BaseNode {
+    static nodeType = "nodetool.text.FilterString";
+    static title = "Filter String";
+    static description = "Filters a stream of strings based on various criteria.\n    filter, strings, text, stream";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static isStreamingOutput = true;
+    static syncMode = "on_any";
+    _filterType = "contains";
+    _criteria = "";
+    async initialize() {
+        this._filterType = String(this.filter_type ?? "contains");
+        this._criteria = String(this.criteria ?? "");
+    }
+    async process() {
+        this._filterType = String(this.filter_type ?? "contains");
+        this._criteria = String(this.criteria ?? "");
+        const value = this.value;
+        if (typeof value !== "string") {
+            return {};
+        }
+        const criteria = this._criteria;
+        const len = value.length;
+        const n = Number(criteria);
+        let matched;
+        switch (this._filterType) {
+            case "contains":
+                matched = value.includes(criteria);
+                break;
+            case "starts_with":
+                matched = value.startsWith(criteria);
+                break;
+            case "ends_with":
+                matched = value.endsWith(criteria);
+                break;
+            case "length_greater":
+                matched = Number.isFinite(n) && len > n;
+                break;
+            case "length_less":
+                matched = Number.isFinite(n) && len < n;
+                break;
+            case "exact_length":
+                matched = Number.isFinite(n) && len === n;
+                break;
+            default:
+                matched = false;
+        }
+        if (!matched) {
+            return {};
+        }
+        return { output: value };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Value",
+        description: "Input string stream"
+    })
+], FilterStringNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "contains",
+        title: "Filter Type",
+        description: "The type of filter to apply",
+        values: [
+            "contains",
+            "starts_with",
+            "ends_with",
+            "length_greater",
+            "length_less",
+            "exact_length"
+        ]
+    })
+], FilterStringNode.prototype, "filter_type", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Criteria",
+        description: "The filtering criteria (text to match or length as string)"
+    })
+], FilterStringNode.prototype, "criteria", void 0);
+export class FilterRegexStringNode extends BaseNode {
+    static nodeType = "nodetool.text.FilterRegexString";
+    static title = "Filter Regex String";
+    static description = "Filters a stream of strings using regular expressions.\n    filter, regex, pattern, text, stream";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static isStreamingOutput = true;
+    static syncMode = "on_any";
+    _pattern = "";
+    _fullMatch = false;
+    async initialize() {
+        this._pattern = String(this.pattern ?? "");
+        this._fullMatch = Boolean(this.full_match ?? false);
+    }
+    async process() {
+        this._pattern = String(this.pattern ?? "");
+        this._fullMatch = Boolean(this.full_match ?? false);
+        const value = this.value;
+        if (typeof value !== "string") {
+            return {};
+        }
+        let regex;
+        try {
+            regex = new RegExp(this._pattern);
+        }
+        catch {
+            return {};
+        }
+        const matched = this._fullMatch
+            ? (value.match(regex)?.[0] ?? "") === value
+            : regex.test(value);
+        if (!matched) {
+            return {};
+        }
+        return { output: value };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Value",
+        description: "Input string stream"
+    })
+], FilterRegexStringNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Pattern",
+        description: "The regular expression pattern to match against."
+    })
+], FilterRegexStringNode.prototype, "pattern", void 0);
+__decorate([
+    prop({
+        type: "bool",
+        default: false,
+        title: "Full Match",
+        description: "Whether to match the entire string or find pattern anywhere in string"
+    })
+], FilterRegexStringNode.prototype, "full_match", void 0);
+export class ConcatTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Concat";
+    static title = "Concatenate Text";
+    static description = "Concatenates text inputs into a single output.\n    text, combine, add, concatenate, merge, join, append";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static isDynamic = true;
+    async process() {
+        const values = [this.a, this.b, ...Array.from(this.dynamicProps.values())].map((value) => String(value ?? ""));
+        return { output: values.join("") };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "A", description: "First text input." })
+], ConcatTextNode.prototype, "a", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "B", description: "Second text input." })
+], ConcatTextNode.prototype, "b", void 0);
+export class JoinTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Join";
+    static title = "Join";
+    static description = "Joins a list of strings into a single string using a specified separator.\n    text, join, combine, concatenate, merge, list";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const list = Array.isArray(this.strings) ? this.strings : [];
+        const sep = String(this.separator ?? "");
+        return { output: list.map((s) => String(s ?? "")).join(sep) };
+    }
+}
+__decorate([
+    prop({
+        type: "list[str]",
+        default: [],
+        title: "Strings",
+        description: "The list of strings to join."
+    })
+], JoinTextNode.prototype, "strings", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Separator", description: "Separator between items." })
+], JoinTextNode.prototype, "separator", void 0);
+export class CollectTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Collect";
+    static title = "Collect Text";
+    static description = "Collects streaming text inputs into a single concatenated string.\n    text, collect, stream, aggregate";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static syncMode = "on_any";
+    _items = [];
+    async initialize() {
+        this._items = [];
+    }
+    async process() {
+        this._items.push(String(this.input_item ?? ""));
+        const sep = String(this.separator ?? "");
+        return { output: this._items.join(sep) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Input Item", description: "Text to collect." })
+], CollectTextNode.prototype, "input_item", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Separator", description: "Separator between collected items." })
+], CollectTextNode.prototype, "separator", void 0);
+export class FormatTextNode extends BaseNode {
+    static nodeType = "nodetool.text.FormatText";
+    static title = "Format Text";
+    static description = "Replaces placeholders in a string with dynamic inputs using {{ variable }} or {variable} syntax.\n    Supports Jinja2-style filters: {{ var|upper }}, {{ var|lower }}, {{ var|capitalize }},\n    {{ var|title }}, {{ var|trim }}, {{ var|truncate(n) }}, {{ var|default(val) }}.\n    text, template, formatting, format, variable, replace\n\n    Use cases:\n    - Generating personalized messages with dynamic content\n    - Creating parameterized queries or commands";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static isDynamic = true;
+    applyFilter(value, filter) {
+        const trimmed = filter.trim();
+        if (trimmed === "upper")
+            return value.toUpperCase();
+        if (trimmed === "lower")
+            return value.toLowerCase();
+        if (trimmed === "capitalize") {
+            return value.length === 0 ? "" : value.charAt(0).toUpperCase() + value.slice(1).toLowerCase();
+        }
+        if (trimmed === "title") {
+            return toTitleCase(value);
+        }
+        if (trimmed === "trim")
+            return value.trim();
+        const truncateMatch = trimmed.match(/^truncate\((\d+)\)$/);
+        if (truncateMatch) {
+            const n = Number(truncateMatch[1]);
+            return value.length <= n ? value : value.slice(0, n) + "...";
+        }
+        const defaultMatch = trimmed.match(/^default\((.+)\)$/);
+        if (defaultMatch) {
+            return value === "" ? defaultMatch[1].replace(/^['"]|['"]$/g, "") : value;
+        }
+        return value;
+    }
+    applyFilters(value, filters) {
+        let result = value;
+        for (const f of filters) {
+            result = this.applyFilter(result, f);
+        }
+        return result;
+    }
+    async process() {
+        let result = String(this.template ?? "");
+        const props = Object.fromEntries(this.dynamicProps);
+        // Handle {{ var|filter1|filter2 }} syntax
+        result = result.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_match, expr) => {
+            const parts = expr.split("|").map((p) => p.trim());
+            const varName = parts[0];
+            if (varName in props) {
+                const strValue = String(props[varName] ?? "");
+                return parts.length > 1 ? this.applyFilters(strValue, parts.slice(1)) : strValue;
+            }
+            return _match;
+        });
+        // Handle {variable} syntax (no filters)
+        for (const [key, value] of Object.entries(props)) {
+            const strValue = String(value ?? "");
+            const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const single = new RegExp(`(?<!\\{)\\{${escapedKey}\\}(?!\\})`, "g");
+            result = result.replace(single, () => strValue);
+        }
+        return { output: result };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "Template",
+        description: "Template string with {{ variable }} or {variable} placeholders."
+    })
+], FormatTextNode.prototype, "template", void 0);
+export class TemplateTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Template";
+    static title = "Template";
+    static description = "Uses template syntax to format strings with variables. Supports {{ variable }} and {variable} patterns.\n    text, template, formatting, format, combine, concatenate, variable, replace\n\n    Use cases:\n    - Generating personalized messages\n    - Creating parameterized queries\n    - Formatting text with variable inputs";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    static isDynamic = true;
+    async process() {
+        let result = String(this.string ?? "");
+        const props = Object.fromEntries(this.dynamicProps);
+        for (const [key, value] of Object.entries(props)) {
+            const strValue = String(value ?? "");
+            const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+            const jinja = new RegExp(`\\{\\{\\s*${escapedKey}\\s*\\}\\}`, "g");
+            result = result.replace(jinja, () => strValue);
+            const single = new RegExp(`(?<!\\{)\\{${escapedKey}\\}(?!\\})`, "g");
+            result = result.replace(single, () => strValue);
+        }
+        return { output: result };
+    }
+}
+__decorate([
+    prop({
+        type: "str",
+        default: "",
+        title: "String",
+        description: "Template string with {{ variable }} or {variable} placeholders."
+    })
+], TemplateTextNode.prototype, "string", void 0);
+export class ReplaceTextNode extends BaseNode {
+    static nodeType = "nodetool.text.Replace";
+    static title = "Replace Text";
+    static description = "Replaces a substring in a text with another substring.\n    text, replace, substitute\n\n    Use cases:\n    - Correcting or updating specific text patterns\n    - Sanitizing or normalizing text data\n    - Implementing simple text transformations";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const text = String(this.text ?? "");
+        const oldStr = String(this.old ?? "");
+        // Support both "new_value" and "new" field names for Python compatibility
+        const newStr = String(this.new_value ?? this["new"] ?? "");
+        if (!oldStr)
+            return { output: text };
+        return { output: text.split(oldStr).join(newStr) };
+    }
+}
+__decorate([
+    prop({ type: "str", default: "", title: "Text", description: "The input text." })
+], ReplaceTextNode.prototype, "text", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "Old", description: "Substring to find." })
+], ReplaceTextNode.prototype, "old", void 0);
+__decorate([
+    prop({ type: "str", default: "", title: "New", description: "Replacement string." })
+], ReplaceTextNode.prototype, "new_value", void 0);
+export class ToStringNode extends BaseNode {
+    static nodeType = "nodetool.text.ToString";
+    static title = "To String";
+    static description = "Converts any input value to its string representation.\n    text, string, convert, repr, str, cast";
+    static metadataOutputTypes = {
+        output: "str"
+    };
+    async process() {
+        const v = this.value;
+        const mode = String(this.mode ?? "str");
+        const toJsonString = (value) => {
+            if (value === undefined) {
+                return "";
+            }
+            try {
+                const json = JSON.stringify(value);
+                if (json === undefined) {
+                    return "";
+                }
+                return json;
+            }
+            catch (_error) {
+                // JSON.stringify can fail for non-serializable values (e.g. circular objects).
+                return String(value);
+            }
+        };
+        if (mode === "repr") {
+            return { output: toJsonString(v) };
+        }
+        if (v === null || v === undefined)
+            return { output: "" };
+        if (typeof v === "object")
+            return { output: toJsonString(v) };
+        return { output: String(v) };
+    }
+}
+__decorate([
+    prop({ type: "any", default: "", title: "Value", description: "The value to convert to string." })
+], ToStringNode.prototype, "value", void 0);
+__decorate([
+    prop({
+        type: "enum",
+        default: "str",
+        title: "Mode",
+        description: "Conversion mode: 'str' for normal string, 'repr' for JSON-quoted representation.",
+        values: ["str", "repr"]
+    })
+], ToStringNode.prototype, "mode", void 0);
+export const TEXT_EXTRA_NODES = [
+    SplitTextNode,
+    ExtractTextNode,
+    ChunkTextNode,
+    ExtractRegexNode,
+    FindAllRegexNode,
+    TextParseJSONNode,
+    ExtractJSONNode,
+    RegexMatchNode,
+    RegexReplaceNode,
+    RegexSplitNode,
+    RegexValidateNode,
+    CompareTextNode,
+    EqualsTextNode,
+    ToUppercaseNode,
+    ToLowercaseNode,
+    ToTitlecaseNode,
+    CapitalizeTextNode,
+    SliceTextNode,
+    StartsWithTextNode,
+    EndsWithTextNode,
+    ContainsTextNode,
+    TrimWhitespaceNode,
+    CollapseWhitespaceNode,
+    IsEmptyTextNode,
+    RemovePunctuationNode,
+    StripAccentsNode,
+    SlugifyNode,
+    HasLengthTextNode,
+    TruncateTextNode,
+    PadTextNode,
+    LengthTextNode,
+    IndexOfTextNode,
+    SurroundWithTextNode,
+    CountTokensNode,
+    HtmlToTextNode,
+    AutomaticSpeechRecognitionNode,
+    EmbeddingTextNode,
+    SaveTextFileNode,
+    SaveTextNode,
+    LoadTextFolderNode,
+    LoadTextAssetsNode,
+    FilterStringNode,
+    FilterRegexStringNode,
+    ConcatTextNode,
+    JoinTextNode,
+    CollectTextNode,
+    FormatTextNode,
+    TemplateTextNode,
+    ReplaceTextNode,
+    ToStringNode
+];
+//# sourceMappingURL=text-extra.js.map