@riotprompt/riotprompt 0.0.1

package/dist/util/markdown.cjs.map

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/util/markdown.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export declare function isMarkdown(input: string | Buffer): boolean;

package/dist/util/markdown.js

@@ -0,0 +1,111 @@
+import { DEFAULT_CHARACTER_ENCODING } from '../constants.js';
+
+// 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(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();
+
+export { isMarkdown };
+//# sourceMappingURL=markdown.js.map

package/dist/util/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.js","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,0BAAAA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/util/storage.cjs

@@ -0,0 +1,155 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const fs = require('fs');
+const glob = require('glob');
+const path = require('path');
+const crypto = require('crypto');
+
+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);
+
+// eslint-disable-next-line no-restricted-imports
+const create = (params)=>{
+    // eslint-disable-next-line no-console
+    const log = params.log || console.log;
+    const exists = async (path)=>{
+        try {
+            await fs__namespace.promises.stat(path);
+            return true;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+            return false;
+        }
+    };
+    const isDirectory = async (path)=>{
+        const stats = await fs__namespace.promises.stat(path);
+        if (!stats.isDirectory()) {
+            log(`${path} is not a directory`);
+            return false;
+        }
+        return true;
+    };
+    const isFile = async (path)=>{
+        const stats = await fs__namespace.promises.stat(path);
+        if (!stats.isFile()) {
+            log(`${path} is not a file`);
+            return false;
+        }
+        return true;
+    };
+    const isReadable = async (path)=>{
+        try {
+            await fs__namespace.promises.access(path, fs__namespace.constants.R_OK);
+        } catch (error) {
+            log(`${path} is not readable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isWritable = async (path)=>{
+        try {
+            await fs__namespace.promises.access(path, fs__namespace.constants.W_OK);
+        } catch (error) {
+            log(`${path} is not writable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isFileReadable = async (path)=>{
+        return await exists(path) && await isFile(path) && await isReadable(path);
+    };
+    const isDirectoryWritable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isWritable(path);
+    };
+    const isDirectoryReadable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isReadable(path);
+    };
+    const createDirectory = async (path)=>{
+        try {
+            await fs__namespace.promises.mkdir(path, {
+                recursive: true
+            });
+        } catch (mkdirError) {
+            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
+        }
+    };
+    const readFile = async (path, encoding)=>{
+        return await fs__namespace.promises.readFile(path, {
+            encoding: encoding
+        });
+    };
+    const writeFile = async (path, data, encoding)=>{
+        await fs__namespace.promises.writeFile(path, data, {
+            encoding: encoding
+        });
+    };
+    const forEachFileIn = async (directory, callback, options = {
+        pattern: '*.*'
+    })=>{
+        try {
+            let filesProcessed = 0;
+            const files = await glob.glob(options.pattern, {
+                cwd: directory,
+                nodir: true
+            });
+            for (const file of files){
+                await callback(path.join(directory, file));
+                filesProcessed++;
+                if (options.limit && filesProcessed >= options.limit) {
+                    log(`Reached limit of ${options.limit} files, stopping`);
+                    break;
+                }
+            }
+        } catch (err) {
+            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
+        }
+    };
+    const readStream = async (path)=>{
+        return fs__namespace.createReadStream(path);
+    };
+    const hashFile = async (path, length)=>{
+        const file = await readFile(path, 'utf8');
+        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);
+    };
+    const listFiles = async (directory)=>{
+        return await fs__namespace.promises.readdir(directory);
+    };
+    return {
+        exists,
+        isDirectory,
+        isFile,
+        isReadable,
+        isWritable,
+        isFileReadable,
+        isDirectoryWritable,
+        isDirectoryReadable,
+        createDirectory,
+        readFile,
+        readStream,
+        writeFile,
+        forEachFileIn,
+        hashFile,
+        listFiles
+    };
+};
+
+exports.create = create;
+//# sourceMappingURL=storage.cjs.map

package/dist/util/storage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.cjs","sources":["../../src/util/storage.ts"],"sourcesContent":["// eslint-disable-next-line no-restricted-imports\nimport * as fs from 'fs';\nimport { glob } from 'glob';\nimport path from 'path';\nimport crypto from 'crypto';\n/**\n * This module exists to isolate filesystem operations from the rest of the codebase.\n * This makes testing easier by avoiding direct fs mocking in jest configuration.\n * \n * Additionally, abstracting storage operations allows for future flexibility - \n * this export utility may need to work with storage systems other than the local filesystem\n * (e.g. S3, Google Cloud Storage, etc).\n */\n\nexport interface Utility {\n    exists: (path: string) => Promise<boolean>;\n    isDirectory: (path: string) => Promise<boolean>;\n    isFile: (path: string) => Promise<boolean>;\n    isReadable: (path: string) => Promise<boolean>;\n    isWritable: (path: string) => Promise<boolean>;\n    isFileReadable: (path: string) => Promise<boolean>;\n    isDirectoryWritable: (path: string) => Promise<boolean>;\n    isDirectoryReadable: (path: string) => Promise<boolean>;\n    createDirectory: (path: string) => Promise<void>;\n    readFile: (path: string, encoding: string) => Promise<string>;\n    readStream: (path: string) => Promise<fs.ReadStream>;\n    writeFile: (path: string, data: string | Buffer, encoding: string) => Promise<void>;\n    forEachFileIn: (directory: string, callback: (path: string) => Promise<void>, options?: { pattern: string, limit?: number }) => Promise<void>;\n    hashFile: (path: string, length: number) => Promise<string>;\n    listFiles: (directory: string) => Promise<string[]>;\n}\n\nexport const create = (params: { log?: (message: string, ...args: any[]) => void }): Utility => {\n\n    // eslint-disable-next-line no-console\n    const log = params.log || console.log;\n\n    const exists = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.stat(path);\n            return true;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        } catch (error: any) {\n            return false;\n        }\n    }\n\n    const isDirectory = async (path: string): Promise<boolean> => {\n        const stats = await fs.promises.stat(path);\n        if (!stats.isDirectory()) {\n            log(`${path} is not a directory`);\n            return false;\n        }\n        return true;\n    }\n\n    const isFile = async (path: string): Promise<boolean> => {\n        const stats = await fs.promises.stat(path);\n        if (!stats.isFile()) {\n            log(`${path} is not a file`);\n            return false;\n        }\n        return true;\n    }\n\n    const isReadable = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.access(path, fs.constants.R_OK);\n        } catch (error: any) {\n            log(`${path} is not readable: %s %s`, error.message, error.stack);\n            return false;\n        }\n        return true;\n    }\n\n    const isWritable = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.access(path, fs.constants.W_OK);\n        } catch (error: any) {\n            log(`${path} is not writable: %s %s`, error.message, error.stack);\n            return false;\n        }\n        return true;\n    }\n\n    const isFileReadable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isFile(path) && await isReadable(path);\n    }\n\n    const isDirectoryWritable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isDirectory(path) && await isWritable(path);\n    }\n\n    const isDirectoryReadable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isDirectory(path) && await isReadable(path);\n    }\n\n    const createDirectory = async (path: string): Promise<void> => {\n        try {\n            await fs.promises.mkdir(path, { recursive: true });\n        } catch (mkdirError: any) {\n            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);\n        }\n    }\n\n    const readFile = async (path: string, encoding: string): Promise<string> => {\n        return await fs.promises.readFile(path, { encoding: encoding as BufferEncoding });\n    }\n\n    const writeFile = async (path: string, data: string | Buffer, encoding: string): Promise<void> => {\n        await fs.promises.writeFile(path, data, { encoding: encoding as BufferEncoding });\n    }\n\n    const forEachFileIn = async (\n        directory: string,\n        callback: (file: string) => Promise<void>,\n        options: { pattern: string | string[], limit?: number } = { pattern: '*.*' },\n    ): Promise<void> => {\n        try {\n            let filesProcessed = 0;\n            const files = await glob(options.pattern, { cwd: directory, nodir: true });\n            for (const file of files) {\n                await callback(path.join(directory, file));\n                filesProcessed++;\n                if (options.limit && filesProcessed >= options.limit) {\n                    log(`Reached limit of ${options.limit} files, stopping`);\n                    break;\n                }\n            }\n        } catch (err: any) {\n            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);\n        }\n    }\n\n    const readStream = async (path: string): Promise<fs.ReadStream> => {\n        return fs.createReadStream(path);\n    }\n\n    const hashFile = async (path: string, length: number): Promise<string> => {\n        const file = await readFile(path, 'utf8');\n        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);\n    }\n\n    const listFiles = async (directory: string): Promise<string[]> => {\n        return await fs.promises.readdir(directory);\n    }\n\n    return {\n        exists,\n        isDirectory,\n        isFile,\n        isReadable,\n        isWritable,\n        isFileReadable,\n        isDirectoryWritable,\n        isDirectoryReadable,\n        createDirectory,\n        readFile,\n        readStream,\n        writeFile,\n        forEachFileIn,\n        hashFile,\n        listFiles,\n    };\n}"],"names":["create","params","log","console","exists","path","fs","promises","stat","error","isDirectory","stats","isFile","isReadable","access","constants","R_OK","message","stack","isWritable","W_OK","isFileReadable","isDirectoryWritable","isDirectoryReadable","createDirectory","mkdir","recursive","mkdirError","Error","readFile","encoding","writeFile","data","forEachFileIn","directory","callback","options","pattern","filesProcessed","files","glob","cwd","nodir","file","join","limit","err","readStream","createReadStream","hashFile","length","crypto","createHash","update","digest","slice","listFiles","readdir"],"mappings":"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"}

package/dist/util/storage.d.ts

@@ -0,0 +1,32 @@
+import * as fs from 'fs';
+/**
+ * This module exists to isolate filesystem operations from the rest of the codebase.
+ * This makes testing easier by avoiding direct fs mocking in jest configuration.
+ *
+ * Additionally, abstracting storage operations allows for future flexibility -
+ * this export utility may need to work with storage systems other than the local filesystem
+ * (e.g. S3, Google Cloud Storage, etc).
+ */
+export interface Utility {
+    exists: (path: string) => Promise<boolean>;
+    isDirectory: (path: string) => Promise<boolean>;
+    isFile: (path: string) => Promise<boolean>;
+    isReadable: (path: string) => Promise<boolean>;
+    isWritable: (path: string) => Promise<boolean>;
+    isFileReadable: (path: string) => Promise<boolean>;
+    isDirectoryWritable: (path: string) => Promise<boolean>;
+    isDirectoryReadable: (path: string) => Promise<boolean>;
+    createDirectory: (path: string) => Promise<void>;
+    readFile: (path: string, encoding: string) => Promise<string>;
+    readStream: (path: string) => Promise<fs.ReadStream>;
+    writeFile: (path: string, data: string | Buffer, encoding: string) => Promise<void>;
+    forEachFileIn: (directory: string, callback: (path: string) => Promise<void>, options?: {
+        pattern: string;
+        limit?: number;
+    }) => Promise<void>;
+    hashFile: (path: string, length: number) => Promise<string>;
+    listFiles: (directory: string) => Promise<string[]>;
+}
+export declare const create: (params: {
+    log?: (message: string, ...args: any[]) => void;
+}) => Utility;

package/dist/util/storage.js

@@ -0,0 +1,132 @@
+import * as fs from 'fs';
+import { glob } from 'glob';
+import path__default from 'path';
+import crypto from 'crypto';
+
+// eslint-disable-next-line no-restricted-imports
+const create = (params)=>{
+    // eslint-disable-next-line no-console
+    const log = params.log || console.log;
+    const exists = async (path)=>{
+        try {
+            await fs.promises.stat(path);
+            return true;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (error) {
+            return false;
+        }
+    };
+    const isDirectory = async (path)=>{
+        const stats = await fs.promises.stat(path);
+        if (!stats.isDirectory()) {
+            log(`${path} is not a directory`);
+            return false;
+        }
+        return true;
+    };
+    const isFile = async (path)=>{
+        const stats = await fs.promises.stat(path);
+        if (!stats.isFile()) {
+            log(`${path} is not a file`);
+            return false;
+        }
+        return true;
+    };
+    const isReadable = async (path)=>{
+        try {
+            await fs.promises.access(path, fs.constants.R_OK);
+        } catch (error) {
+            log(`${path} is not readable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isWritable = async (path)=>{
+        try {
+            await fs.promises.access(path, fs.constants.W_OK);
+        } catch (error) {
+            log(`${path} is not writable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isFileReadable = async (path)=>{
+        return await exists(path) && await isFile(path) && await isReadable(path);
+    };
+    const isDirectoryWritable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isWritable(path);
+    };
+    const isDirectoryReadable = async (path)=>{
+        return await exists(path) && await isDirectory(path) && await isReadable(path);
+    };
+    const createDirectory = async (path)=>{
+        try {
+            await fs.promises.mkdir(path, {
+                recursive: true
+            });
+        } catch (mkdirError) {
+            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
+        }
+    };
+    const readFile = async (path, encoding)=>{
+        return await fs.promises.readFile(path, {
+            encoding: encoding
+        });
+    };
+    const writeFile = async (path, data, encoding)=>{
+        await fs.promises.writeFile(path, data, {
+            encoding: encoding
+        });
+    };
+    const forEachFileIn = async (directory, callback, options = {
+        pattern: '*.*'
+    })=>{
+        try {
+            let filesProcessed = 0;
+            const files = await glob(options.pattern, {
+                cwd: directory,
+                nodir: true
+            });
+            for (const file of files){
+                await callback(path__default.join(directory, file));
+                filesProcessed++;
+                if (options.limit && filesProcessed >= options.limit) {
+                    log(`Reached limit of ${options.limit} files, stopping`);
+                    break;
+                }
+            }
+        } catch (err) {
+            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
+        }
+    };
+    const readStream = async (path)=>{
+        return fs.createReadStream(path);
+    };
+    const hashFile = async (path, length)=>{
+        const file = await readFile(path, 'utf8');
+        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);
+    };
+    const listFiles = async (directory)=>{
+        return await fs.promises.readdir(directory);
+    };
+    return {
+        exists,
+        isDirectory,
+        isFile,
+        isReadable,
+        isWritable,
+        isFileReadable,
+        isDirectoryWritable,
+        isDirectoryReadable,
+        createDirectory,
+        readFile,
+        readStream,
+        writeFile,
+        forEachFileIn,
+        hashFile,
+        listFiles
+    };
+};
+
+export { create };
+//# sourceMappingURL=storage.js.map

package/dist/util/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","sources":["../../src/util/storage.ts"],"sourcesContent":["// eslint-disable-next-line no-restricted-imports\nimport * as fs from 'fs';\nimport { glob } from 'glob';\nimport path from 'path';\nimport crypto from 'crypto';\n/**\n * This module exists to isolate filesystem operations from the rest of the codebase.\n * This makes testing easier by avoiding direct fs mocking in jest configuration.\n * \n * Additionally, abstracting storage operations allows for future flexibility - \n * this export utility may need to work with storage systems other than the local filesystem\n * (e.g. S3, Google Cloud Storage, etc).\n */\n\nexport interface Utility {\n    exists: (path: string) => Promise<boolean>;\n    isDirectory: (path: string) => Promise<boolean>;\n    isFile: (path: string) => Promise<boolean>;\n    isReadable: (path: string) => Promise<boolean>;\n    isWritable: (path: string) => Promise<boolean>;\n    isFileReadable: (path: string) => Promise<boolean>;\n    isDirectoryWritable: (path: string) => Promise<boolean>;\n    isDirectoryReadable: (path: string) => Promise<boolean>;\n    createDirectory: (path: string) => Promise<void>;\n    readFile: (path: string, encoding: string) => Promise<string>;\n    readStream: (path: string) => Promise<fs.ReadStream>;\n    writeFile: (path: string, data: string | Buffer, encoding: string) => Promise<void>;\n    forEachFileIn: (directory: string, callback: (path: string) => Promise<void>, options?: { pattern: string, limit?: number }) => Promise<void>;\n    hashFile: (path: string, length: number) => Promise<string>;\n    listFiles: (directory: string) => Promise<string[]>;\n}\n\nexport const create = (params: { log?: (message: string, ...args: any[]) => void }): Utility => {\n\n    // eslint-disable-next-line no-console\n    const log = params.log || console.log;\n\n    const exists = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.stat(path);\n            return true;\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        } catch (error: any) {\n            return false;\n        }\n    }\n\n    const isDirectory = async (path: string): Promise<boolean> => {\n        const stats = await fs.promises.stat(path);\n        if (!stats.isDirectory()) {\n            log(`${path} is not a directory`);\n            return false;\n        }\n        return true;\n    }\n\n    const isFile = async (path: string): Promise<boolean> => {\n        const stats = await fs.promises.stat(path);\n        if (!stats.isFile()) {\n            log(`${path} is not a file`);\n            return false;\n        }\n        return true;\n    }\n\n    const isReadable = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.access(path, fs.constants.R_OK);\n        } catch (error: any) {\n            log(`${path} is not readable: %s %s`, error.message, error.stack);\n            return false;\n        }\n        return true;\n    }\n\n    const isWritable = async (path: string): Promise<boolean> => {\n        try {\n            await fs.promises.access(path, fs.constants.W_OK);\n        } catch (error: any) {\n            log(`${path} is not writable: %s %s`, error.message, error.stack);\n            return false;\n        }\n        return true;\n    }\n\n    const isFileReadable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isFile(path) && await isReadable(path);\n    }\n\n    const isDirectoryWritable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isDirectory(path) && await isWritable(path);\n    }\n\n    const isDirectoryReadable = async (path: string): Promise<boolean> => {\n        return await exists(path) && await isDirectory(path) && await isReadable(path);\n    }\n\n    const createDirectory = async (path: string): Promise<void> => {\n        try {\n            await fs.promises.mkdir(path, { recursive: true });\n        } catch (mkdirError: any) {\n            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);\n        }\n    }\n\n    const readFile = async (path: string, encoding: string): Promise<string> => {\n        return await fs.promises.readFile(path, { encoding: encoding as BufferEncoding });\n    }\n\n    const writeFile = async (path: string, data: string | Buffer, encoding: string): Promise<void> => {\n        await fs.promises.writeFile(path, data, { encoding: encoding as BufferEncoding });\n    }\n\n    const forEachFileIn = async (\n        directory: string,\n        callback: (file: string) => Promise<void>,\n        options: { pattern: string | string[], limit?: number } = { pattern: '*.*' },\n    ): Promise<void> => {\n        try {\n            let filesProcessed = 0;\n            const files = await glob(options.pattern, { cwd: directory, nodir: true });\n            for (const file of files) {\n                await callback(path.join(directory, file));\n                filesProcessed++;\n                if (options.limit && filesProcessed >= options.limit) {\n                    log(`Reached limit of ${options.limit} files, stopping`);\n                    break;\n                }\n            }\n        } catch (err: any) {\n            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);\n        }\n    }\n\n    const readStream = async (path: string): Promise<fs.ReadStream> => {\n        return fs.createReadStream(path);\n    }\n\n    const hashFile = async (path: string, length: number): Promise<string> => {\n        const file = await readFile(path, 'utf8');\n        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);\n    }\n\n    const listFiles = async (directory: string): Promise<string[]> => {\n        return await fs.promises.readdir(directory);\n    }\n\n    return {\n        exists,\n        isDirectory,\n        isFile,\n        isReadable,\n        isWritable,\n        isFileReadable,\n        isDirectoryWritable,\n        isDirectoryReadable,\n        createDirectory,\n        readFile,\n        readStream,\n        writeFile,\n        forEachFileIn,\n        hashFile,\n        listFiles,\n    };\n}"],"names":["create","params","log","console","exists","path","fs","promises","stat","error","isDirectory","stats","isFile","isReadable","access","constants","R_OK","message","stack","isWritable","W_OK","isFileReadable","isDirectoryWritable","isDirectoryReadable","createDirectory","mkdir","recursive","mkdirError","Error","readFile","encoding","writeFile","data","forEachFileIn","directory","callback","options","pattern","filesProcessed","files","glob","cwd","nodir","file","join","limit","err","readStream","createReadStream","hashFile","length","crypto","createHash","update","digest","slice","listFiles","readdir"],"mappings":"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"}

package/dist/util/text.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const constants = require('../constants.cjs');
+
+// Returns true if the input is likely text, false if likely binary
+function isText(input) {
+    let buf;
+    if (typeof input === 'string') {
+        buf = Buffer.from(input, constants.DEFAULT_CHARACTER_ENCODING);
+    } else {
+        buf = input;
+    }
+    // Empty buffers are considered text
+    if (buf.length === 0) {
+        return true;
+    }
+    // If the buffer contains null bytes, it's likely binary
+    if (buf.includes(0)) {
+        return false;
+    }
+    // For UTF-8 encoded text (including emoji and international characters),
+    // convert to string first and check if there are non-printable characters
+    const str = buf.toString(constants.DEFAULT_CHARACTER_ENCODING);
+    // Count the number of non-printable ASCII characters (excluding common whitespace)
+    let nonPrintable = 0;
+    const len = Math.min(str.length, 512); // Only check the first 512 characters for performance
+    for(let i = 0; i < len; i++){
+        const charCode = str.charCodeAt(i);
+        // Allow: tab (9), line feed (10), carriage return (13), printable ASCII (32-126)
+        // Also allow all non-ASCII Unicode characters (charCode > 127)
+        if (charCode !== 9 && charCode !== 10 && charCode !== 13 && (charCode < 32 || charCode > 126 && charCode < 128)) {
+            nonPrintable++;
+        }
+    }
+    // If more than 10% of the checked characters are non-printable, consider it binary
+    return nonPrintable / len < 0.1;
+}
+
+exports.isText = isText;
+//# sourceMappingURL=text.cjs.map

package/dist/util/text.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.cjs","sources":["../../src/util/text.ts"],"sourcesContent":["import { DEFAULT_CHARACTER_ENCODING } from \"../constants\";\n\n// Returns true if the input is likely text, false if likely binary\nexport function isText(input: string | Buffer): boolean {\n    let buf: Buffer;\n    if (typeof input === 'string') {\n        buf = Buffer.from(input, DEFAULT_CHARACTER_ENCODING);\n    } else {\n        buf = input;\n    }\n\n    // Empty buffers are considered text\n    if (buf.length === 0) {\n        return true;\n    }\n\n    // If the buffer contains null bytes, it's likely binary\n    if (buf.includes(0)) {\n        return false;\n    }\n\n    // For UTF-8 encoded text (including emoji and international characters),\n    // convert to string first and check if there are non-printable characters\n    const str = buf.toString(DEFAULT_CHARACTER_ENCODING);\n\n    // Count the number of non-printable ASCII characters (excluding common whitespace)\n    let nonPrintable = 0;\n    const len = Math.min(str.length, 512); // Only check the first 512 characters for performance\n\n    for (let i = 0; i < len; i++) {\n        const charCode = str.charCodeAt(i);\n        // Allow: tab (9), line feed (10), carriage return (13), printable ASCII (32-126)\n        // Also allow all non-ASCII Unicode characters (charCode > 127)\n        if (\n            charCode !== 9 && charCode !== 10 && charCode !== 13 &&\n            (charCode < 32 || (charCode > 126 && charCode < 128))\n        ) {\n            nonPrintable++;\n        }\n    }\n\n    // If more than 10% of the checked characters are non-printable, consider it binary\n    return nonPrintable / len < 0.1;\n}\n"],"names":["isText","input","buf","Buffer","from","DEFAULT_CHARACTER_ENCODING","length","includes","str","toString","nonPrintable","len","Math","min","i","charCode","charCodeAt"],"mappings":";;;;;;AAEA;AACO,SAASA,OAAOC,KAAsB,EAAA;IACzC,IAAIC,GAAAA;IACJ,IAAI,OAAOD,UAAU,QAAU,EAAA;QAC3BC,GAAMC,GAAAA,MAAAA,CAAOC,IAAI,CAACH,KAAOI,EAAAA,oCAAAA,CAAAA;KACtB,MAAA;QACHH,GAAMD,GAAAA,KAAAA;AACV;;IAGA,IAAIC,GAAAA,CAAII,MAAM,KAAK,CAAG,EAAA;QAClB,OAAO,IAAA;AACX;;IAGA,IAAIJ,GAAAA,CAAIK,QAAQ,CAAC,CAAI,CAAA,EAAA;QACjB,OAAO,KAAA;AACX;;;IAIA,MAAMC,GAAAA,GAAMN,GAAIO,CAAAA,QAAQ,CAACJ,oCAAAA,CAAAA;;AAGzB,IAAA,IAAIK,YAAe,GAAA,CAAA;IACnB,MAAMC,GAAAA,GAAMC,KAAKC,GAAG,CAACL,IAAIF,MAAM,EAAE;AAEjC,IAAA,IAAK,IAAIQ,CAAAA,GAAI,CAAGA,EAAAA,CAAAA,GAAIH,KAAKG,CAAK,EAAA,CAAA;QAC1B,MAAMC,QAAAA,GAAWP,GAAIQ,CAAAA,UAAU,CAACF,CAAAA,CAAAA;;;AAGhC,QAAA,IACIC,QAAa,KAAA,CAAA,IAAKA,QAAa,KAAA,EAAA,IAAMA,QAAa,KAAA,EAAA,KACjDA,QAAAA,GAAW,EAAOA,IAAAA,QAAAA,GAAW,GAAOA,IAAAA,QAAAA,GAAW,GAAG,CACrD,EAAA;AACEL,YAAAA,YAAAA,EAAAA;AACJ;AACJ;;AAGA,IAAA,OAAOA,eAAeC,GAAM,GAAA,GAAA;AAChC;;;;"}

package/dist/util/text.d.ts

@@ -0,0 +1 @@
+export declare function isText(input: string | Buffer): boolean;

package/dist/util/text.js

@@ -0,0 +1,38 @@
+import { DEFAULT_CHARACTER_ENCODING } from '../constants.js';
+
+// Returns true if the input is likely text, false if likely binary
+function isText(input) {
+    let buf;
+    if (typeof input === 'string') {
+        buf = Buffer.from(input, DEFAULT_CHARACTER_ENCODING);
+    } else {
+        buf = input;
+    }
+    // Empty buffers are considered text
+    if (buf.length === 0) {
+        return true;
+    }
+    // If the buffer contains null bytes, it's likely binary
+    if (buf.includes(0)) {
+        return false;
+    }
+    // For UTF-8 encoded text (including emoji and international characters),
+    // convert to string first and check if there are non-printable characters
+    const str = buf.toString(DEFAULT_CHARACTER_ENCODING);
+    // Count the number of non-printable ASCII characters (excluding common whitespace)
+    let nonPrintable = 0;
+    const len = Math.min(str.length, 512); // Only check the first 512 characters for performance
+    for(let i = 0; i < len; i++){
+        const charCode = str.charCodeAt(i);
+        // Allow: tab (9), line feed (10), carriage return (13), printable ASCII (32-126)
+        // Also allow all non-ASCII Unicode characters (charCode > 127)
+        if (charCode !== 9 && charCode !== 10 && charCode !== 13 && (charCode < 32 || charCode > 126 && charCode < 128)) {
+            nonPrintable++;
+        }
+    }
+    // If more than 10% of the checked characters are non-printable, consider it binary
+    return nonPrintable / len < 0.1;
+}
+
+export { isText };
+//# sourceMappingURL=text.js.map