@riotprompt/riotprompt 0.0.1 → 0.0.2

package/dist/parse/markdown.cjs

@@ -1,114 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const marked = require('marked');
-const section = require('../items/section.cjs');
-const weighted = require('../items/weighted.cjs');
-
-const parseMarkdown = (input, options = {})=>{
-    let markdownContent;
-    if (typeof input === 'string') {
-        markdownContent = input;
-    } else {
-        markdownContent = input.toString();
-    }
-    const sectionOptions = section.SectionOptionsSchema.parse(options);
-    // Use marked.lexer to get tokens without full parsing/rendering
-    const tokens = marked.marked.lexer(markdownContent);
-    // Create the main section (with a Title from the options)
-    const mainSection = section.create(sectionOptions);
-    // Track sections at each depth level
-    const sectionStack = [
-        mainSection
-    ];
-    // Set if we've seen the first token
-    let isFirstToken = true;
-    // Set the item options
-    const itemOptions = weighted.WeightedOptionsSchema.parse({
-        ...sectionOptions,
-        weight: sectionOptions.itemWeight
-    });
-    for (const token of tokens){
-        switch(token.type){
-            case 'heading':
-                {
-                    const depth = token.depth;
-                    // If this is the first token and it's a heading, use it as the main section title
-                    if (isFirstToken) {
-                        mainSection.title = token.text;
-                        isFirstToken = false;
-                        break;
-                    }
-                    isFirstToken = false;
-                    // Create a new section with this heading
-                    const newSection = section.create({
-                        ...sectionOptions,
-                        title: token.text
-                    });
-                    // Ensure the section stack has the right size based on this heading's depth
-                    // (e.g., a depth-2 heading should be added to the depth-1 section)
-                    // We need to ensure the stack length is exactly depth, not just less than or equal to depth
-                    while(sectionStack.length > depth && sectionStack.length > 1){
-                        sectionStack.pop();
-                    }
-                    // Make sure we're at the right level for this heading
-                    // If we stay at the same heading level (e.g., two h2s in sequence),
-                    // we need to pop once more to get to the parent level
-                    if (sectionStack.length === depth && sectionStack.length > 1) {
-                        sectionStack.pop();
-                    }
-                    // Add new section to its parent
-                    const parentSection = sectionStack[sectionStack.length - 1];
-                    parentSection.add(newSection, itemOptions);
-                    // Push this section onto the stack
-                    sectionStack.push(newSection);
-                    break;
-                }
-            case 'paragraph':
-                {
-                    isFirstToken = false;
-                    const instruction = weighted.create(token.text, itemOptions);
-                    const currentSection = sectionStack[sectionStack.length - 1];
-                    currentSection.add(instruction, itemOptions);
-                    break;
-                }
-            case 'list':
-                {
-                    isFirstToken = false;
-                    // Convert list items to instructions
-                    const listInstructionContent = token.items.map((item)=>`- ${item.text}`).join('\n');
-                    const listInstruction = weighted.create(listInstructionContent, itemOptions);
-                    const currentSection = sectionStack[sectionStack.length - 1];
-                    currentSection.add(listInstruction, itemOptions);
-                    break;
-                }
-            case 'code':
-                {
-                    isFirstToken = false;
-                    // Represent code blocks as instructions
-                    const codeInstruction = weighted.create(`\`\`\`${token.lang || ''}\n${token.text}\n\`\`\``, itemOptions);
-                    const currentSection = sectionStack[sectionStack.length - 1];
-                    currentSection.add(codeInstruction, itemOptions);
-                    break;
-                }
-            case 'space':
-                break;
-            default:
-                {
-                    isFirstToken = false;
-                    // Treat other block tokens' text as instructions for robustness
-                    if ('text' in token && token.text) {
-                        const fallbackInstruction = weighted.create(token.text, itemOptions);
-                        const currentSection = sectionStack[sectionStack.length - 1];
-                        currentSection.add(fallbackInstruction, itemOptions);
-                    }
-                    break;
-                }
-        }
-    }
-    return mainSection;
-};
-
-exports.parseMarkdown = parseMarkdown;
-//# sourceMappingURL=markdown.cjs.map

package/dist/parse/markdown.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.cjs","sources":["../../src/parse/markdown.ts"],"sourcesContent":["import { marked } from 'marked';\nimport { create as createSection, Section, SectionOptions, SectionOptionsSchema } from '../items/section';\nimport { create as createWeighted, Weighted, WeightedOptionsSchema } from '../items/weighted';\n\nexport const parseMarkdown = <T extends Weighted>(\n    input: string | Buffer,\n    options: Partial<SectionOptions> = {}\n): Section<T> => {\n\n    let markdownContent;\n    if (typeof input === 'string') {\n        markdownContent = input;\n    } else {\n        markdownContent = input.toString();\n    }\n\n    const sectionOptions = SectionOptionsSchema.parse(options);\n\n    // Use marked.lexer to get tokens without full parsing/rendering\n    const tokens = marked.lexer(markdownContent);\n\n    // Create the main section (with a Title from the options)\n    const mainSection = createSection<T>(sectionOptions);\n\n    // Track sections at each depth level\n    const sectionStack: Section<T>[] = [mainSection];\n\n    // Set if we've seen the first token\n    let isFirstToken = true;\n\n    // Set the item options\n    const itemOptions = WeightedOptionsSchema.parse({\n        ...sectionOptions,\n        weight: sectionOptions.itemWeight,\n    });\n\n    for (const token of tokens) {\n        switch (token.type) {\n            case 'heading': {\n                const depth = token.depth;\n\n                // If this is the first token and it's a heading, use it as the main section title\n                if (isFirstToken) {\n                    mainSection.title = token.text;\n                    isFirstToken = false;\n                    break;\n                }\n\n                isFirstToken = false;\n\n                // Create a new section with this heading\n                const newSection = createSection<T>({ ...sectionOptions, title: token.text });\n\n                // Ensure the section stack has the right size based on this heading's depth\n                // (e.g., a depth-2 heading should be added to the depth-1 section)\n                // We need to ensure the stack length is exactly depth, not just less than or equal to depth\n                while (sectionStack.length > depth && sectionStack.length > 1) {\n                    sectionStack.pop();\n                }\n\n                // Make sure we're at the right level for this heading\n                // If we stay at the same heading level (e.g., two h2s in sequence),\n                // we need to pop once more to get to the parent level\n                if (sectionStack.length === depth && sectionStack.length > 1) {\n                    sectionStack.pop();\n                }\n\n                // Add new section to its parent\n                const parentSection = sectionStack[sectionStack.length - 1];\n                parentSection.add(newSection, itemOptions);\n\n                // Push this section onto the stack\n                sectionStack.push(newSection);\n                break;\n            }\n\n            case 'paragraph': {\n                isFirstToken = false;\n                const instruction: T = createWeighted<T>(token.text, itemOptions);\n                const currentSection = sectionStack[sectionStack.length - 1];\n                currentSection.add(instruction, itemOptions);\n                break;\n            }\n\n            case 'list': {\n                isFirstToken = false;\n                // Convert list items to instructions\n                const listInstructionContent = token.items.map((item: any) => `- ${item.text}`).join('\\n');\n                const listInstruction: T = createWeighted<T>(listInstructionContent, itemOptions);\n                const currentSection = sectionStack[sectionStack.length - 1];\n                currentSection.add(listInstruction, itemOptions);\n                break;\n            }\n\n            case 'code': {\n                isFirstToken = false;\n                // Represent code blocks as instructions\n                const codeInstruction: T = createWeighted<T>(`\\`\\`\\`${token.lang || ''}\\n${token.text}\\n\\`\\`\\``, itemOptions);\n                const currentSection = sectionStack[sectionStack.length - 1];\n                currentSection.add(codeInstruction, itemOptions);\n                break;\n            }\n\n            case 'space':\n                // Usually ignore space tokens between block elements\n                break;\n\n            default: {\n                isFirstToken = false;\n                // Treat other block tokens' text as instructions for robustness\n                if ('text' in token && token.text) {\n                    const fallbackInstruction: T = createWeighted<T>(token.text, itemOptions);\n                    const currentSection = sectionStack[sectionStack.length - 1];\n                    currentSection.add(fallbackInstruction, itemOptions);\n                }\n                break;\n            }\n        }\n    }\n    return mainSection;\n}\n"],"names":["parseMarkdown","input","options","markdownContent","toString","sectionOptions","SectionOptionsSchema","parse","tokens","marked","lexer","mainSection","createSection","sectionStack","isFirstToken","itemOptions","WeightedOptionsSchema","weight","itemWeight","token","type","depth","title","text","newSection","length","pop","parentSection","add","push","instruction","createWeighted","currentSection","listInstructionContent","items","map","item","join","listInstruction","codeInstruction","lang","fallbackInstruction"],"mappings":"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"}

package/dist/parse/text.cjs

@@ -1,33 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const section = require('../items/section.cjs');
-const weighted = require('../items/weighted.cjs');
-
-const parseText = (input, options = {})=>{
-    let text;
-    if (typeof input === 'string') {
-        text = input;
-    } else {
-        text = input.toString();
-    }
-    const sectionOptions = section.SectionOptionsSchema.parse(options);
-    // Set the item options
-    const itemOptions = weighted.WeightedOptionsSchema.parse({
-        ...sectionOptions,
-        weight: sectionOptions.itemWeight
-    });
-    // Split the text on newlines
-    const lines = text.split(/\r?\n/).filter((line)=>line.trim().length > 0);
-    // Create the main section with the supplied title
-    const mainSection = section.create(sectionOptions);
-    for (const line of lines){
-        const instruction = weighted.create(line, itemOptions);
-        mainSection.add(instruction, itemOptions);
-    }
-    return mainSection;
-};
-
-exports.parseText = parseText;
-//# sourceMappingURL=text.cjs.map

package/dist/parse/text.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"text.cjs","sources":["../../src/parse/text.ts"],"sourcesContent":["import { create as createSection, Section, SectionOptions, SectionOptionsSchema } from '../items/section';\nimport { create as createWeighted, Weighted, WeightedOptionsSchema } from '../items/weighted';\n\nexport const parseText = <T extends Weighted>(\n    input: string | Buffer,\n    options: Partial<SectionOptions> = {}\n): Section<T> => {\n\n    let text;\n    if (typeof input === 'string') {\n        text = input;\n    } else {\n        text = input.toString();\n    }\n\n    const sectionOptions = SectionOptionsSchema.parse(options);\n\n    // Set the item options\n    const itemOptions = WeightedOptionsSchema.parse({\n        ...sectionOptions,\n        weight: sectionOptions.itemWeight,\n    });\n\n    // Split the text on newlines\n    const lines = text.split(/\\r?\\n/).filter(line => line.trim().length > 0);\n\n    // Create the main section with the supplied title\n    const mainSection = createSection<T>(sectionOptions);\n\n    for (const line of lines) {\n        const instruction: T = createWeighted<T>(line, itemOptions);\n        mainSection.add(instruction, itemOptions);\n    }\n\n    return mainSection;\n}\n"],"names":["parseText","input","options","text","toString","sectionOptions","SectionOptionsSchema","parse","itemOptions","WeightedOptionsSchema","weight","itemWeight","lines","split","filter","line","trim","length","mainSection","createSection","instruction","createWeighted","add"],"mappings":";;;;;;;MAGaA,SAAY,GAAA,CACrBC,KACAC,EAAAA,OAAAA,GAAmC,EAAE,GAAA;IAGrC,IAAIC,IAAAA;IACJ,IAAI,OAAOF,UAAU,QAAU,EAAA;QAC3BE,IAAOF,GAAAA,KAAAA;KACJ,MAAA;AACHE,QAAAA,IAAAA,GAAOF,MAAMG,QAAQ,EAAA;AACzB;IAEA,MAAMC,cAAAA,GAAiBC,4BAAqBC,CAAAA,KAAK,CAACL,OAAAA,CAAAA;;IAGlD,MAAMM,WAAAA,GAAcC,8BAAsBF,CAAAA,KAAK,CAAC;AAC5C,QAAA,GAAGF,cAAc;AACjBK,QAAAA,MAAAA,EAAQL,eAAeM;AAC3B,KAAA,CAAA;;AAGA,IAAA,MAAMC,KAAQT,GAAAA,IAAAA,CAAKU,KAAK,CAAC,OAASC,CAAAA,CAAAA,MAAM,CAACC,CAAAA,IAAQA,GAAAA,IAAAA,CAAKC,IAAI,EAAA,CAAGC,MAAM,GAAG,CAAA,CAAA;;AAGtE,IAAA,MAAMC,cAAcC,cAAiBd,CAAAA,cAAAA,CAAAA;IAErC,KAAK,MAAMU,QAAQH,KAAO,CAAA;QACtB,MAAMQ,WAAAA,GAAiBC,gBAAkBN,IAAMP,EAAAA,WAAAA,CAAAA;QAC/CU,WAAYI,CAAAA,GAAG,CAACF,WAAaZ,EAAAA,WAAAA,CAAAA;AACjC;IAEA,OAAOU,WAAAA;AACX;;;;"}

package/dist/parser.cjs

@@ -1,99 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const fs = require('fs/promises');
-const path = require('path');
-const zod = require('zod');
-const parameters = require('./items/parameters.cjs');
-const section = require('./items/section.cjs');
-const logger = require('./logger.cjs');
-const markdown$1 = require('./parse/markdown.cjs');
-const text$1 = require('./parse/text.cjs');
-const markdown = require('./util/markdown.cjs');
-const text = require('./util/text.cjs');
-
-function _interopNamespaceDefault(e) {
-    const n = Object.create(null, { [Symbol.toStringTag]: { value: 'Module' } });
-    if (e) {
-        for (const k in e) {
-            if (k !== 'default') {
-                const d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: () => e[k]
-                });
-            }
-        }
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-const fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-const path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-
-const OptionsSchema = zod.z.object({
-    logger: zod.z.any().optional().default(logger.DEFAULT_LOGGER),
-    parameters: parameters.ParametersSchema.optional().default({})
-});
-const create = (parserOptions)=>{
-    const options = OptionsSchema.parse(parserOptions || {});
-    const parameters = options.parameters;
-    const logger$1 = logger.wrapLogger(options.logger, 'Parser');
-    const loadOptions = (sectionOptions = {})=>{
-        const currentOptions = section.SectionOptionsSchema.parse(sectionOptions);
-        return {
-            ...currentOptions,
-            parameters: {
-                ...parameters,
-                ...currentOptions.parameters
-            }
-        };
-    };
-    const parseFile = async (filePath, options = {})=>{
-        const currentOptions = loadOptions(options);
-        try {
-            const content = await fs__namespace.readFile(filePath, 'utf-8');
-            // Only use the filename as title if no title was explicitly provided
-            const fileName = path__namespace.basename(filePath, path__namespace.extname(filePath));
-            return parse(content, {
-                ...currentOptions,
-                title: (currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.title) || fileName
-            });
-        } catch (error) {
-            // Log the error or handle it appropriately
-            logger$1.error(`Error reading or parsing file with marked at ${filePath}:`, error);
-            throw new Error(`Failed to parse instructions from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    };
-    /**
-     * Reads Markdown content and parses it into a single Section.
-     * 
-     * - If the content starts with a heading, that becomes the title of the returned Section
-     * - If no heading at the start, creates a Section with no title
-     * - Headers within the content create nested sections based on their depth
-     * - All content is organized in a hierarchical structure based on heading levels
-     *
-     * @param content The content to parse
-     * @returns A Section containing all content in a hierarchical structure
-     */ const parse = (content, options = {})=>{
-        const currentOptions = loadOptions(options);
-        let mainSection;
-        if (markdown.isMarkdown(content)) {
-            mainSection = markdown$1.parseMarkdown(content, currentOptions);
-        } else if (text.isText(content)) {
-            mainSection = text$1.parseText(content, currentOptions);
-        } else {
-            throw new Error(`Unsupported content supplied to parse, riotprompt currently only supports markdown and text`);
-        }
-        return mainSection;
-    };
-    return {
-        parse,
-        parseFile
-    };
-};
-
-exports.create = create;
-//# sourceMappingURL=parser.cjs.map

package/dist/parser.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser.cjs","sources":["../src/parser.ts"],"sourcesContent":["import * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { z } from 'zod';\nimport { ParametersSchema } from './items/parameters';\nimport { Section, SectionOptions, SectionOptionsSchema } from './items/section';\nimport { Weighted } from './items/weighted';\nimport { DEFAULT_LOGGER, wrapLogger } from './logger';\nimport { parseMarkdown } from './parse/markdown';\nimport { parseText } from './parse/text';\nimport { isMarkdown } from './util/markdown';\nimport { isText } from './util/text';\n\nconst OptionsSchema = z.object({\n    logger: z.any().optional().default(DEFAULT_LOGGER),\n    parameters: ParametersSchema.optional().default({}),\n});\n\nexport type Options = z.infer<typeof OptionsSchema>;\n\nexport type OptionsParam = Partial<Options>;\n\nexport interface Instance {\n    parse: <T extends Weighted>(input: string | Buffer, options?: SectionOptions) => Section<T>;\n    parseFile: <T extends Weighted>(filePath: string, options?: SectionOptions) => Promise<Section<T>>;\n}\n\nexport const create = (parserOptions?: OptionsParam): Instance => {\n    const options: Required<Options> = OptionsSchema.parse(parserOptions || {}) as Required<Options>;\n    const parameters = options.parameters;\n\n    const logger = wrapLogger(options.logger, 'Parser');\n\n    const loadOptions = (sectionOptions: Partial<SectionOptions> = {}): SectionOptions => {\n        const currentOptions = SectionOptionsSchema.parse(sectionOptions);\n        return {\n            ...currentOptions,\n            parameters: {\n                ...parameters,\n                ...currentOptions.parameters\n            }\n        }\n    }\n\n    const parseFile = async <T extends Weighted>(\n        filePath: string,\n        options: Partial<SectionOptions> = {}\n    ): Promise<Section<T>> => {\n        const currentOptions = loadOptions(options);\n        try {\n            const content = await fs.readFile(filePath, 'utf-8');\n            // Only use the filename as title if no title was explicitly provided\n            const fileName = path.basename(filePath, path.extname(filePath));\n            return parse(content, {\n                ...currentOptions,\n                title: currentOptions?.title || fileName\n            });\n        } catch (error) {\n            // Log the error or handle it appropriately\n            logger.error(`Error reading or parsing file with marked at ${filePath}:`, error);\n            throw new Error(`Failed to parse instructions from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);\n        }\n    }\n\n    /**\n     * Reads Markdown content and parses it into a single Section.\n     * \n     * - If the content starts with a heading, that becomes the title of the returned Section\n     * - If no heading at the start, creates a Section with no title\n     * - Headers within the content create nested sections based on their depth\n     * - All content is organized in a hierarchical structure based on heading levels\n     *\n     * @param content The content to parse\n     * @returns A Section containing all content in a hierarchical structure\n     */\n    const parse = <T extends Weighted>(\n        content: string | Buffer,\n        options: Partial<SectionOptions> = {}\n    ): Section<T> => {\n        const currentOptions = loadOptions(options);\n\n        let mainSection: Section<T>;\n        if (isMarkdown(content)) {\n            mainSection = parseMarkdown<T>(content, currentOptions);\n        } else if (isText(content)) {\n            mainSection = parseText<T>(content, currentOptions);\n        } else {\n            throw new Error(`Unsupported content supplied to parse, riotprompt currently only supports markdown and text`);\n        }\n        return mainSection;\n    }\n\n    return {\n        parse,\n        parseFile\n    }\n}"],"names":["OptionsSchema","z","object","logger","any","optional","default","DEFAULT_LOGGER","parameters","ParametersSchema","create","parserOptions","options","parse","wrapLogger","loadOptions","sectionOptions","currentOptions","SectionOptionsSchema","parseFile","filePath","content","fs","readFile","fileName","path","basename","extname","title","error","Error","message","String","mainSection","isMarkdown","parseMarkdown","isText","parseText"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,MAAMA,aAAAA,GAAgBC,KAAEC,CAAAA,MAAM,CAAC;AAC3BC,IAAAA,MAAAA,EAAQF,MAAEG,GAAG,EAAA,CAAGC,QAAQ,EAAA,CAAGC,OAAO,CAACC,qBAAAA,CAAAA;AACnCC,IAAAA,UAAAA,EAAYC,2BAAiBJ,CAAAA,QAAQ,EAAGC,CAAAA,OAAO,CAAC,EAAC;AACrD,CAAA,CAAA;AAWO,MAAMI,SAAS,CAACC,aAAAA,GAAAA;AACnB,IAAA,MAAMC,OAA6BZ,GAAAA,aAAAA,CAAca,KAAK,CAACF,iBAAiB,EAAC,CAAA;IACzE,MAAMH,UAAAA,GAAaI,QAAQJ,UAAU;AAErC,IAAA,MAAML,QAASW,GAAAA,iBAAAA,CAAWF,OAAQT,CAAAA,MAAM,EAAE,QAAA,CAAA;AAE1C,IAAA,MAAMY,WAAc,GAAA,CAACC,cAA0C,GAAA,EAAE,GAAA;QAC7D,MAAMC,cAAAA,GAAiBC,4BAAqBL,CAAAA,KAAK,CAACG,cAAAA,CAAAA;QAClD,OAAO;AACH,YAAA,GAAGC,cAAc;YACjBT,UAAY,EAAA;AACR,gBAAA,GAAGA,UAAU;AACb,gBAAA,GAAGS,eAAeT;AACtB;AACJ,SAAA;AACJ,KAAA;AAEA,IAAA,MAAMW,SAAY,GAAA,OACdC,QACAR,EAAAA,OAAAA,GAAmC,EAAE,GAAA;AAErC,QAAA,MAAMK,iBAAiBF,WAAYH,CAAAA,OAAAA,CAAAA;QACnC,IAAI;AACA,YAAA,MAAMS,OAAU,GAAA,MAAMC,aAAGC,CAAAA,QAAQ,CAACH,QAAU,EAAA,OAAA,CAAA;;AAE5C,YAAA,MAAMI,WAAWC,eAAKC,CAAAA,QAAQ,CAACN,QAAUK,EAAAA,eAAAA,CAAKE,OAAO,CAACP,QAAAA,CAAAA,CAAAA;AACtD,YAAA,OAAOP,MAAMQ,OAAS,EAAA;AAClB,gBAAA,GAAGJ,cAAc;AACjBW,gBAAAA,KAAAA,EAAOX,CAAAA,cAAAA,KAAAA,IAAAA,IAAAA,cAAAA,KAAAA,KAAAA,CAAAA,GAAAA,KAAAA,CAAAA,GAAAA,cAAAA,CAAgBW,KAAK,KAAIJ;AACpC,aAAA,CAAA;AACJ,SAAA,CAAE,OAAOK,KAAO,EAAA;;YAEZ1B,QAAO0B,CAAAA,KAAK,CAAC,CAAC,6CAA6C,EAAET,QAAS,CAAA,CAAC,CAAC,EAAES,KAAAA,CAAAA;AAC1E,YAAA,MAAM,IAAIC,KAAAA,CAAM,CAAC,kCAAkC,EAAEV,QAAS,CAAA,EAAE,EAAES,KAAAA,YAAiBC,KAAQD,GAAAA,KAAAA,CAAME,OAAO,GAAGC,OAAOH,KAAQ,CAAA,CAAA,CAAA,CAAA;AAC9H;AACJ,KAAA;AAEA;;;;;;;;;;AAUC,QACD,MAAMhB,KAAQ,GAAA,CACVQ,OACAT,EAAAA,OAAAA,GAAmC,EAAE,GAAA;AAErC,QAAA,MAAMK,iBAAiBF,WAAYH,CAAAA,OAAAA,CAAAA;QAEnC,IAAIqB,WAAAA;AACJ,QAAA,IAAIC,oBAAWb,OAAU,CAAA,EAAA;AACrBY,YAAAA,WAAAA,GAAcE,yBAAiBd,OAASJ,EAAAA,cAAAA,CAAAA;SACrC,MAAA,IAAImB,YAAOf,OAAU,CAAA,EAAA;AACxBY,YAAAA,WAAAA,GAAcI,iBAAahB,OAASJ,EAAAA,cAAAA,CAAAA;SACjC,MAAA;AACH,YAAA,MAAM,IAAIa,KAAAA,CAAM,CAAC,2FAA2F,CAAC,CAAA;AACjH;QACA,OAAOG,WAAAA;AACX,KAAA;IAEA,OAAO;AACHpB,QAAAA,KAAAA;AACAM,QAAAA;AACJ,KAAA;AACJ;;;;"}

package/dist/prompt.cjs

@@ -1,15 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const create = ({ persona, instructions, contents, contexts })=>{
-    return {
-        persona,
-        instructions,
-        contents,
-        contexts
-    };
-};
-
-exports.create = create;
-//# sourceMappingURL=prompt.cjs.map

package/dist/prompt.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"prompt.cjs","sources":["../src/prompt.ts"],"sourcesContent":["import { Content } from \"./items/content\";\nimport { Context } from \"./items/context\";\nimport { Instruction } from \"./items/instruction\";\nimport { Section } from \"./items/section\";\n\nexport interface Prompt {\n    persona?: Section<Instruction>;\n    instructions: Section<Instruction>;\n    contents?: Section<Content>;\n    contexts?: Section<Context>;\n}\n\nexport const create = ({\n    persona,\n    instructions,\n    contents,\n    contexts,\n}: {\n    persona?: Section<Instruction>,\n    instructions: Section<Instruction>,\n    contents?: Section<Content>,\n    contexts?: Section<Context>\n}): Prompt => {\n\n    return {\n        persona,\n        instructions,\n        contents,\n        contexts,\n    }\n}"],"names":["create","persona","instructions","contents","contexts"],"mappings":";;;;AAYO,MAAMA,MAAS,GAAA,CAAC,EACnBC,OAAO,EACPC,YAAY,EACZC,QAAQ,EACRC,QAAQ,EAMX,GAAA;IAEG,OAAO;AACHH,QAAAA,OAAAA;AACAC,QAAAA,YAAAA;AACAC,QAAAA,QAAAA;AACAC,QAAAA;AACJ,KAAA;AACJ;;;;"}

package/dist/util/general.cjs

@@ -1,52 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const clean = (obj)=>{
-    return Object.fromEntries(Object.entries(obj).filter(([_, v])=>v !== undefined));
-};
-//Recursive implementation of jSON.stringify;
-const stringifyJSON = function(obj, visited = new Set()) {
-    const arrOfKeyVals = [];
-    const arrVals = [];
-    let objKeys = [];
-    /*********CHECK FOR PRIMITIVE TYPES**********/ if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null) return '' + obj;
-    else if (typeof obj === 'string') return '"' + obj + '"';
-    /*********DETECT CIRCULAR REFERENCES**********/ if (obj instanceof Object && visited.has(obj)) {
-        return '"(circular)"';
-    } else if (Array.isArray(obj)) {
-        //check for empty array
-        if (obj[0] === undefined) return '[]';
-        else {
-            // Add array to visited before processing its elements
-            visited.add(obj);
-            obj.forEach(function(el) {
-                arrVals.push(stringifyJSON(el, visited));
-            });
-            return '[' + arrVals + ']';
-        }
-    } else if (obj instanceof Object) {
-        // Add object to visited before processing its properties
-        visited.add(obj);
-        //get object keys
-        objKeys = Object.keys(obj);
-        //set key output;
-        objKeys.forEach(function(key) {
-            const keyOut = '"' + key + '":';
-            const keyValOut = obj[key];
-            //skip functions and undefined properties
-            if (keyValOut instanceof Function || keyValOut === undefined) return; // Skip this entry entirely instead of pushing an empty string
-            else if (typeof keyValOut === 'string') arrOfKeyVals.push(keyOut + '"' + keyValOut + '"');
-            else if (typeof keyValOut === 'boolean' || typeof keyValOut === 'number' || keyValOut === null) arrOfKeyVals.push(keyOut + keyValOut);
-            else if (keyValOut instanceof Object) {
-                arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, visited));
-            }
-        });
-        return '{' + arrOfKeyVals + '}';
-    }
-    return '';
-};
-
-exports.clean = clean;
-exports.stringifyJSON = stringifyJSON;
-//# sourceMappingURL=general.cjs.map

package/dist/util/general.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"general.cjs","sources":["../../src/util/general.ts"],"sourcesContent":["export const clean = (obj: any) => {\n    return Object.fromEntries(\n        Object.entries(obj).filter(([_, v]) => v !== undefined)\n    );\n}\n\n//Recursive implementation of jSON.stringify;\nexport const stringifyJSON = function (obj: any, visited: Set<any> = new Set()): string {\n    const arrOfKeyVals: string[] = [];\n    const arrVals: string[] = [];\n    let objKeys: string[] = [];\n\n    /*********CHECK FOR PRIMITIVE TYPES**********/\n    if (typeof obj === 'number' || typeof obj === 'boolean' || obj === null)\n        return '' + obj;\n    else if (typeof obj === 'string')\n        return '\"' + obj + '\"';\n\n    /*********DETECT CIRCULAR REFERENCES**********/\n    if (obj instanceof Object && visited.has(obj)) {\n        return '\"(circular)\"';\n    }\n\n    /*********CHECK FOR ARRAY**********/\n    else if (Array.isArray(obj)) {\n        //check for empty array\n        if (obj[0] === undefined)\n            return '[]';\n        else {\n            // Add array to visited before processing its elements\n            visited.add(obj);\n            obj.forEach(function (el) {\n                arrVals.push(stringifyJSON(el, visited));\n            });\n            return '[' + arrVals + ']';\n        }\n    }\n    /*********CHECK FOR OBJECT**********/\n    else if (obj instanceof Object) {\n        // Add object to visited before processing its properties\n        visited.add(obj);\n        //get object keys\n        objKeys = Object.keys(obj);\n        //set key output;\n        objKeys.forEach(function (key) {\n            const keyOut = '\"' + key + '\":';\n            const keyValOut = obj[key];\n            //skip functions and undefined properties\n            if (keyValOut instanceof Function || keyValOut === undefined)\n                return; // Skip this entry entirely instead of pushing an empty string\n            else if (typeof keyValOut === 'string')\n                arrOfKeyVals.push(keyOut + '\"' + keyValOut + '\"');\n            else if (typeof keyValOut === 'boolean' || typeof keyValOut === 'number' || keyValOut === null)\n                arrOfKeyVals.push(keyOut + keyValOut);\n            //check for nested objects, call recursively until no more objects\n            else if (keyValOut instanceof Object) {\n                arrOfKeyVals.push(keyOut + stringifyJSON(keyValOut, visited));\n            }\n        });\n        return '{' + arrOfKeyVals + '}';\n    }\n    return '';\n};"],"names":["clean","obj","Object","fromEntries","entries","filter","_","v","undefined","stringifyJSON","visited","Set","arrOfKeyVals","arrVals","objKeys","has","Array","isArray","add","forEach","el","push","keys","key","keyOut","keyValOut","Function"],"mappings":";;;;AAAO,MAAMA,QAAQ,CAACC,GAAAA,GAAAA;AAClB,IAAA,OAAOC,MAAOC,CAAAA,WAAW,CACrBD,MAAAA,CAAOE,OAAO,CAACH,GAAAA,CAAAA,CAAKI,MAAM,CAAC,CAAC,CAACC,CAAGC,EAAAA,CAAAA,CAAE,GAAKA,CAAMC,KAAAA,SAAAA,CAAAA,CAAAA;AAErD;AAEA;MACaC,aAAgB,GAAA,SAAUR,GAAQ,EAAES,OAAAA,GAAoB,IAAIC,GAAK,EAAA,EAAA;AAC1E,IAAA,MAAMC,eAAyB,EAAE;AACjC,IAAA,MAAMC,UAAoB,EAAE;AAC5B,IAAA,IAAIC,UAAoB,EAAE;mDAG1B,IAAI,OAAOb,GAAQ,KAAA,QAAA,IAAY,OAAOA,GAAAA,KAAQ,SAAaA,IAAAA,GAAAA,KAAQ,IAC/D,EAAA,OAAO,EAAKA,GAAAA,GAAAA;AACX,SAAA,IAAI,OAAOA,GAAAA,KAAQ,QACpB,EAAA,OAAO,MAAMA,GAAM,GAAA,GAAA;AAEvB,oDACA,IAAIA,GAAAA,YAAeC,UAAUQ,OAAQK,CAAAA,GAAG,CAACd,GAAM,CAAA,EAAA;QAC3C,OAAO,cAAA;AACX,KAAA,MAGK,IAAIe,KAAAA,CAAMC,OAAO,CAAChB,GAAM,CAAA,EAAA;;AAEzB,QAAA,IAAIA,GAAG,CAAC,CAAE,CAAA,KAAKO,WACX,OAAO,IAAA;AACN,aAAA;;AAEDE,YAAAA,OAAAA,CAAQQ,GAAG,CAACjB,GAAAA,CAAAA;YACZA,GAAIkB,CAAAA,OAAO,CAAC,SAAUC,EAAE,EAAA;gBACpBP,OAAQQ,CAAAA,IAAI,CAACZ,aAAAA,CAAcW,EAAIV,EAAAA,OAAAA,CAAAA,CAAAA;AACnC,aAAA,CAAA;AACA,YAAA,OAAO,MAAMG,OAAU,GAAA,GAAA;AAC3B;KAGC,MAAA,IAAIZ,eAAeC,MAAQ,EAAA;;AAE5BQ,QAAAA,OAAAA,CAAQQ,GAAG,CAACjB,GAAAA,CAAAA;;QAEZa,OAAUZ,GAAAA,MAAAA,CAAOoB,IAAI,CAACrB,GAAAA,CAAAA;;QAEtBa,OAAQK,CAAAA,OAAO,CAAC,SAAUI,GAAG,EAAA;YACzB,MAAMC,MAAAA,GAAS,MAAMD,GAAM,GAAA,IAAA;YAC3B,MAAME,SAAAA,GAAYxB,GAAG,CAACsB,GAAI,CAAA;;AAE1B,YAAA,IAAIE,SAAqBC,YAAAA,QAAAA,IAAYD,SAAcjB,KAAAA,SAAAA,EAC/C;iBACC,IAAI,OAAOiB,cAAc,QAC1Bb,EAAAA,YAAAA,CAAaS,IAAI,CAACG,MAAAA,GAAS,MAAMC,SAAY,GAAA,GAAA,CAAA;iBAC5C,IAAI,OAAOA,SAAc,KAAA,SAAA,IAAa,OAAOA,SAAAA,KAAc,QAAYA,IAAAA,SAAAA,KAAc,IACtFb,EAAAA,YAAAA,CAAaS,IAAI,CAACG,MAASC,GAAAA,SAAAA,CAAAA;AAE1B,iBAAA,IAAIA,qBAAqBvB,MAAQ,EAAA;AAClCU,gBAAAA,YAAAA,CAAaS,IAAI,CAACG,MAASf,GAAAA,aAAAA,CAAcgB,SAAWf,EAAAA,OAAAA,CAAAA,CAAAA;AACxD;AACJ,SAAA,CAAA;AACA,QAAA,OAAO,MAAME,YAAe,GAAA,GAAA;AAChC;IACA,OAAO,EAAA;AACX;;;;;"}

package/dist/util/markdown.cjs

@@ -1,115 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const constants = require('../constants.cjs');
-
-// Heuristic to check for Markdown syntax. This is not a full parser.
-// It looks for common Markdown patterns.
-const markdownRegex = /^(#+\s|\*\s|-\s|\+\s|>\s|\[.*\]\(.*\)|```|~~~|---\\s*$)/m;
-/**
- * Inspects a string to see if it likely contains Markdown syntax.
- *
- * @param input The string or Buffer content to inspect.
- * @returns True if Markdown syntax is suspected, false otherwise.
- */ function isMarkdown(input) {
-    if (input == null) {
-        return false;
-    }
-    // Convert Buffer to string if necessary
-    const content = typeof input === 'string' ? input : input.toString(constants.DEFAULT_CHARACTER_ENCODING);
-    if (!content || content.trim() === '') {
-        return false; // Empty string is not considered Markdown
-    }
-    // Check for common Markdown patterns in the entire content
-    if (markdownRegex.test(content)) {
-        return true;
-    }
-    // Fallback: Check for a high prevalence of Markdown-like list/header starters
-    // or thematic breaks, or code blocks.
-    // We'll consider up to the first ~2000 characters, roughly equivalent to the byte check.
-    const effectiveContent = content.length > 2000 ? content.substring(0, 2000) : content;
-    const lines = effectiveContent.split('\n');
-    let markdownFeatureCount = 0;
-    const featurePatterns = [
-        /^#+\s+.+/,
-        /^\s*[*+-]\s+.+/,
-        /^\s*>\s+.+/,
-        /\[.+\]\(.+\)/,
-        /!\[.+\]\(.+\)/,
-        /`{1,3}[^`]+`{1,3}/,
-        /^\s*_{3,}\s*$/,
-        /^\s*-{3,}\s*$/,
-        /^\s*\*{3,}\s*$/
-    ];
-    for (const line of lines){
-        // Stop checking if we have already found enough features to be confident.
-        // This is a small optimization for very long inputs that are clearly markdown early on.
-        if (markdownFeatureCount >= 2 && lines.length > 10) {
-            const significantLineCountEarly = Math.min(lines.indexOf(line) + 1, 20);
-            if (significantLineCountEarly > 0 && markdownFeatureCount / significantLineCountEarly > 0.1) {
-                return true;
-            }
-        }
-        for (const pattern of featurePatterns){
-            if (pattern.test(line.trim())) {
-                markdownFeatureCount++;
-                break; // Count each line only once
-            }
-        }
-    }
-    // If more than 5% of the first few lines (up to 20 lines or all lines if fewer)
-    // show markdown features, or if there are at least 2 distinct features in short texts,
-    // consider it Markdown.
-    const significantLineCount = Math.min(lines.length, 20);
-    if (significantLineCount > 0) {
-        // Calculate the exact threshold percentage
-        const thresholdPercentage = markdownFeatureCount / significantLineCount;
-        // Check against the 5% threshold (0.05)
-        // Using >= 0.05 exactly matches 5%, > 0.05 requires more than 5%
-        if (thresholdPercentage >= 0.05 + 0.0001) {
-            return true;
-        }
-        // Other conditions for returning true
-        if (markdownFeatureCount >= 1 && significantLineCount <= 5 || markdownFeatureCount >= 2) {
-            return true;
-        }
-    }
-    return false;
-} // Example usage (optional, for testing):
- // function testIsMarkdownString() {
- //   console.log('--- Testing isMarkdownString ---');
- //   const markdown1 = '# Hello World\\nThis is a test.';
- //   console.log(`Test 1 (Header): "${markdown1.substring(0,10)}..." -> ${isMarkdownString(markdown1)}`); // true
- //   const markdown2 = '* Item 1\\n* Item 2';
- //   console.log(`Test 2 (List): "${markdown2.substring(0,10)}..." -> ${isMarkdownString(markdown2)}`); // true
- //   const markdown3 = '[Google](https://google.com)';
- //   console.log(`Test 3 (Link): "${markdown3.substring(0,15)}..." -> ${isMarkdownString(markdown3)}`); // true
- //   const markdown4 = '> This is a quote.';
- //   console.log(`Test 4 (Blockquote): "${markdown4.substring(0,10)}..." -> ${isMarkdownString(markdown4)}`); // true
- //   const markdown5 = '```javascript\\nconsole.log("hello");\\n```';
- //   console.log(`Test 5 (Code block): "${markdown5.substring(0,15)}..." -> ${isMarkdownString(markdown5)}`); // true
- //   const text1 = 'This is a plain text string.';
- //   console.log(`Test 6 (Plain text): "${text1.substring(0,10)}..." -> ${isMarkdownString(text1)}`); // false
- //   const text2 = 'hello_world.this_is_a_test_string_with_underscores_but_not_markdown_thematic_break';
- //   console.log(`Test 7 (Long non-markdown): "${text2.substring(0,10)}..." -> ${isMarkdownString(text2)}`); // false
- //   const text3 = '<xml><tag>value</tag></xml>';
- //   console.log(`Test 8 (XML): "${text3.substring(0,10)}..." -> ${isMarkdownString(text3)}`); // false
- //   const shortMarkdown = '# H';
- //   console.log(`Test 9 (Short Markdown): "${shortMarkdown}" -> ${isMarkdownString(shortMarkdown)}`); // true
- //   const shortNonMarkdown = 'Hello';
- //   console.log(`Test 10 (Short Non-Markdown): "${shortNonMarkdown}" -> ${isMarkdownString(shortNonMarkdown)}`); // false
- //   const emptyString = '';
- //   console.log(`Test 11 (Empty string): "" -> ${isMarkdownString(emptyString)}`); // false
- //   const whitespaceString = '   \t \n  ';
- //   console.log(`Test 12 (Whitespace string): "${whitespaceString.substring(0,5)}..." -> ${isMarkdownString(whitespaceString)}`); // false
- //   const markdownWithManyFeatures = `# Title\\n\\n* list\\n* list2\\n\\n> quote here\\n\\n\`\`\`\\ncode\\n\`\`\`\\n\\nnormal text paragraph with a [link](url).\n---\nAnother paragraph.\nThis is just a test string to see how it performs with multiple markdown features present.\nHello world this is a very long line that does not contain any markdown syntax at all, it is just plain text that goes on and on.\n* Another list item\n* And another one\n# Another Header\n## Subheader\nThis is fun.\nOkay I think this is enough.\nFinal line.\nAnother final line.\nOne more for good measure.\nOkay that should be enough lines to test the early exit.\n`;
- //   console.log(`Test 13 (Many Features): "${markdownWithManyFeatures.substring(0,10)}..." -> ${isMarkdownString(markdownWithManyFeatures)}`); // true
- //   const htmlLike = '<div><p>Hello</p><ul><li>item</li></ul></div>';
- //   console.log(`Test 14 (HTML-like): "${htmlLike.substring(0,10)}..." -> ${isMarkdownString(htmlLike)}`); // false
- //   console.log('--- End Testing ---');
- // }
- // testIsMarkdownString();
-
-exports.isMarkdown = isMarkdown;
-//# sourceMappingURL=markdown.cjs.map

package/dist/util/markdown.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"markdown.cjs","sources":["../../src/util/markdown.ts"],"sourcesContent":["import { DEFAULT_CHARACTER_ENCODING } from \"../constants\";\n\n// Heuristic to check for Markdown syntax. This is not a full parser.\n// It looks for common Markdown patterns.\nconst markdownRegex = /^(#+\\s|\\*\\s|-\\s|\\+\\s|>\\s|\\[.*\\]\\(.*\\)|```|~~~|---\\\\s*$)/m;\n\n/**\n * Inspects a string to see if it likely contains Markdown syntax.\n *\n * @param input The string or Buffer content to inspect.\n * @returns True if Markdown syntax is suspected, false otherwise.\n */\nexport function isMarkdown(input: string | Buffer): boolean {\n    if (input == null) {\n        return false;\n    }\n    // Convert Buffer to string if necessary\n    const content = typeof input === 'string' ? input : input.toString(DEFAULT_CHARACTER_ENCODING);\n    if (!content || content.trim() === '') {\n        return false; // Empty string is not considered Markdown\n    }\n\n    // Check for common Markdown patterns in the entire content\n    if (markdownRegex.test(content)) {\n        return true;\n    }\n\n    // Fallback: Check for a high prevalence of Markdown-like list/header starters\n    // or thematic breaks, or code blocks.\n    // We'll consider up to the first ~2000 characters, roughly equivalent to the byte check.\n    const effectiveContent = content.length > 2000 ? content.substring(0, 2000) : content;\n    const lines = effectiveContent.split('\\n');\n    let markdownFeatureCount = 0;\n    const featurePatterns = [\n        /^#+\\s+.+/,      // Headers (e.g., # Heading)\n        /^\\s*[*+-]\\s+.+/, // List items (e.g., * item, - item, + item)\n        /^\\s*>\\s+.+/,      // Blockquotes (e.g., > quote)\n        /\\[.+\\]\\(.+\\)/,   // Links (e.g., [text](url))\n        /!\\[.+\\]\\(.+\\)/,  // Images (e.g., ![alt](src))\n        /`{1,3}[^`]+`{1,3}/, // Inline code (e.g., `code`) or code blocks (```code```)\n        /^\\s*_{3,}\\s*$/,  // Thematic breaks (e.g., ---, ***, ___)\n        /^\\s*-{3,}\\s*$/,\n        /^\\s*\\*{3,}\\s*$/\n    ];\n\n    for (const line of lines) {\n        // Stop checking if we have already found enough features to be confident.\n        // This is a small optimization for very long inputs that are clearly markdown early on.\n        if (markdownFeatureCount >= 2 && lines.length > 10) { // Heuristic threshold\n            const significantLineCountEarly = Math.min(lines.indexOf(line) + 1, 20);\n            if (significantLineCountEarly > 0 && markdownFeatureCount / significantLineCountEarly > 0.1) {\n                return true;\n            }\n        }\n\n        for (const pattern of featurePatterns) {\n            if (pattern.test(line.trim())) {\n                markdownFeatureCount++;\n                break; // Count each line only once\n            }\n        }\n    }\n\n    // If more than 5% of the first few lines (up to 20 lines or all lines if fewer)\n    // show markdown features, or if there are at least 2 distinct features in short texts,\n    // consider it Markdown.\n    const significantLineCount = Math.min(lines.length, 20);\n    if (significantLineCount > 0) {\n        // Calculate the exact threshold percentage\n        const thresholdPercentage = markdownFeatureCount / significantLineCount;\n\n        // Check against the 5% threshold (0.05)\n        // Using >= 0.05 exactly matches 5%, > 0.05 requires more than 5%\n        if (thresholdPercentage >= 0.05 + 0.0001) { // Adding a small epsilon to ensure exactly 5% passes but just below fails\n            return true;\n        }\n\n        // Other conditions for returning true\n        if ((markdownFeatureCount >= 1 && significantLineCount <= 5) || markdownFeatureCount >= 2) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\n// Example usage (optional, for testing):\n// function testIsMarkdownString() {\n//   console.log('--- Testing isMarkdownString ---');\n//   const markdown1 = '# Hello World\\\\nThis is a test.';\n//   console.log(`Test 1 (Header): \"${markdown1.substring(0,10)}...\" -> ${isMarkdownString(markdown1)}`); // true\n\n//   const markdown2 = '* Item 1\\\\n* Item 2';\n//   console.log(`Test 2 (List): \"${markdown2.substring(0,10)}...\" -> ${isMarkdownString(markdown2)}`); // true\n\n//   const markdown3 = '[Google](https://google.com)';\n//   console.log(`Test 3 (Link): \"${markdown3.substring(0,15)}...\" -> ${isMarkdownString(markdown3)}`); // true\n\n//   const markdown4 = '> This is a quote.';\n//   console.log(`Test 4 (Blockquote): \"${markdown4.substring(0,10)}...\" -> ${isMarkdownString(markdown4)}`); // true\n\n//   const markdown5 = '```javascript\\\\nconsole.log(\"hello\");\\\\n```';\n//   console.log(`Test 5 (Code block): \"${markdown5.substring(0,15)}...\" -> ${isMarkdownString(markdown5)}`); // true\n\n//   const text1 = 'This is a plain text string.';\n//   console.log(`Test 6 (Plain text): \"${text1.substring(0,10)}...\" -> ${isMarkdownString(text1)}`); // false\n\n//   const text2 = 'hello_world.this_is_a_test_string_with_underscores_but_not_markdown_thematic_break';\n//   console.log(`Test 7 (Long non-markdown): \"${text2.substring(0,10)}...\" -> ${isMarkdownString(text2)}`); // false\n\n//   const text3 = '<xml><tag>value</tag></xml>';\n//   console.log(`Test 8 (XML): \"${text3.substring(0,10)}...\" -> ${isMarkdownString(text3)}`); // false\n\n//   const shortMarkdown = '# H';\n//   console.log(`Test 9 (Short Markdown): \"${shortMarkdown}\" -> ${isMarkdownString(shortMarkdown)}`); // true\n\n//   const shortNonMarkdown = 'Hello';\n//   console.log(`Test 10 (Short Non-Markdown): \"${shortNonMarkdown}\" -> ${isMarkdownString(shortNonMarkdown)}`); // false\n\n//   const emptyString = '';\n//   console.log(`Test 11 (Empty string): \"\" -> ${isMarkdownString(emptyString)}`); // false\n\n//   const whitespaceString = '   \\t \\n  ';\n//   console.log(`Test 12 (Whitespace string): \"${whitespaceString.substring(0,5)}...\" -> ${isMarkdownString(whitespaceString)}`); // false\n\n//   const markdownWithManyFeatures = `# Title\\\\n\\\\n* list\\\\n* list2\\\\n\\\\n> quote here\\\\n\\\\n\\`\\`\\`\\\\ncode\\\\n\\`\\`\\`\\\\n\\\\nnormal text paragraph with a [link](url).\\n---\\nAnother paragraph.\\nThis is just a test string to see how it performs with multiple markdown features present.\\nHello world this is a very long line that does not contain any markdown syntax at all, it is just plain text that goes on and on.\\n* Another list item\\n* And another one\\n# Another Header\\n## Subheader\\nThis is fun.\\nOkay I think this is enough.\\nFinal line.\\nAnother final line.\\nOne more for good measure.\\nOkay that should be enough lines to test the early exit.\\n`;\n//   console.log(`Test 13 (Many Features): \"${markdownWithManyFeatures.substring(0,10)}...\" -> ${isMarkdownString(markdownWithManyFeatures)}`); // true\n\n//   const htmlLike = '<div><p>Hello</p><ul><li>item</li></ul></div>';\n//   console.log(`Test 14 (HTML-like): \"${htmlLike.substring(0,10)}...\" -> ${isMarkdownString(htmlLike)}`); // false\n\n//   console.log('--- End Testing ---');\n// }\n\n// testIsMarkdownString();\n"],"names":["markdownRegex","isMarkdown","input","content","toString","DEFAULT_CHARACTER_ENCODING","trim","test","effectiveContent","length","substring","lines","split","markdownFeatureCount","featurePatterns","line","significantLineCountEarly","Math","min","indexOf","pattern","significantLineCount","thresholdPercentage"],"mappings":";;;;;;AAEA;AACA;AACA,MAAMA,aAAgB,GAAA,0DAAA;AAEtB;;;;;IAMO,SAASC,UAAAA,CAAWC,KAAsB,EAAA;AAC7C,IAAA,IAAIA,SAAS,IAAM,EAAA;QACf,OAAO,KAAA;AACX;;AAEA,IAAA,MAAMC,UAAU,OAAOD,KAAAA,KAAU,WAAWA,KAAQA,GAAAA,KAAAA,CAAME,QAAQ,CAACC,oCAAAA,CAAAA;AACnE,IAAA,IAAI,CAACF,OAAAA,IAAWA,OAAQG,CAAAA,IAAI,OAAO,EAAI,EAAA;AACnC,QAAA,OAAO;AACX;;IAGA,IAAIN,aAAAA,CAAcO,IAAI,CAACJ,OAAU,CAAA,EAAA;QAC7B,OAAO,IAAA;AACX;;;;IAKA,MAAMK,gBAAAA,GAAmBL,QAAQM,MAAM,GAAG,OAAON,OAAQO,CAAAA,SAAS,CAAC,CAAA,EAAG,IAAQP,CAAAA,GAAAA,OAAAA;IAC9E,MAAMQ,KAAAA,GAAQH,gBAAiBI,CAAAA,KAAK,CAAC,IAAA,CAAA;AACrC,IAAA,IAAIC,oBAAuB,GAAA,CAAA;AAC3B,IAAA,MAAMC,eAAkB,GAAA;AACpB,QAAA,UAAA;AACA,QAAA,gBAAA;AACA,QAAA,YAAA;AACA,QAAA,cAAA;AACA,QAAA,eAAA;AACA,QAAA,mBAAA;AACA,QAAA,eAAA;AACA,QAAA,eAAA;AACA,QAAA;AACH,KAAA;IAED,KAAK,MAAMC,QAAQJ,KAAO,CAAA;;;AAGtB,QAAA,IAAIE,oBAAwB,IAAA,CAAA,IAAKF,KAAMF,CAAAA,MAAM,GAAG,EAAI,EAAA;YAChD,MAAMO,yBAAAA,GAA4BC,KAAKC,GAAG,CAACP,MAAMQ,OAAO,CAACJ,QAAQ,CAAG,EAAA,EAAA,CAAA;AACpE,YAAA,IAAIC,yBAA4B,GAAA,CAAA,IAAKH,oBAAuBG,GAAAA,yBAAAA,GAA4B,GAAK,EAAA;gBACzF,OAAO,IAAA;AACX;AACJ;QAEA,KAAK,MAAMI,WAAWN,eAAiB,CAAA;AACnC,YAAA,IAAIM,OAAQb,CAAAA,IAAI,CAACQ,IAAAA,CAAKT,IAAI,EAAK,CAAA,EAAA;AAC3BO,gBAAAA,oBAAAA,EAAAA;AACA,gBAAA,MAAA;AACJ;AACJ;AACJ;;;;AAKA,IAAA,MAAMQ,uBAAuBJ,IAAKC,CAAAA,GAAG,CAACP,KAAAA,CAAMF,MAAM,EAAE,EAAA,CAAA;AACpD,IAAA,IAAIY,uBAAuB,CAAG,EAAA;;AAE1B,QAAA,MAAMC,sBAAsBT,oBAAuBQ,GAAAA,oBAAAA;;;QAInD,IAAIC,mBAAAA,IAAuB,OAAO,MAAQ,EAAA;YACtC,OAAO,IAAA;AACX;;AAGA,QAAA,IAAI,oBAAyB,IAAA,CAAA,IAAKD,oBAAwB,IAAA,CAAA,IAAMR,wBAAwB,CAAG,EAAA;YACvF,OAAO,IAAA;AACX;AACJ;IAEA,OAAO,KAAA;AACX,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}