@promptbook/markitdown 0.86.22 → 0.86.31

package/esm/index.es.js

@@ -26,7 +26,7 @@ const BOOK_LANGUAGE_VERSION = '1.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.86.22';
+const PROMPTBOOK_ENGINE_VERSION = '0.86.31';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3636,119 +3636,60 @@ function valueToString(value) {
 }
 
 /**
- * Extract all used variable names from ginen JavaScript/TypeScript script
+ * Parses the given script and returns the list of all used variables that are not defined in the script
  *
- * @param script JavaScript/TypeScript script
- * @returns Set of variable names
+ * @param script from which to extract the variables
+ * @returns the list of variable names
  * @throws {ParseError} if the script is invalid
- * @public exported from `@promptbook/utils` <- Note: [👖] This is usable elsewhere than in Promptbook, so keeping in utils
+ * @public exported from `@promptbook/execute-javascript`
  */
-function extractVariablesFromScript(script) {
-    if (script.trim() === '') {
-        return new Set();
-    }
+function extractVariablesFromJavascript(script) {
     const variables = new Set();
-    // JS keywords and builtins to exclude
-    const exclude = new Set([
-        // Keywords
-        'break',
-        'case',
-        'catch',
-        'class',
-        'const',
-        'continue',
-        'debugger',
-        'default',
-        'delete',
-        'do',
-        'else',
-        'export',
-        'extends',
-        'false',
-        'finally',
-        'for',
-        'function',
-        'if',
-        'import',
-        'in',
-        'instanceof',
-        'let',
-        'new',
-        'null',
-        'return',
-        'super',
-        'switch',
-        'this',
-        'throw',
-        'true',
-        'try',
-        'typeof',
-        'var',
-        'void',
-        'while',
-        'with',
-        'yield',
-        // Common globals
-        'console',
-        'JSON',
-        'Error',
-        // Typescript types
-        'string',
-        'number',
-        'boolean',
-        'object',
-        'symbol',
-        // Common methods on built-in objects
-        'test',
-        'match',
-        'exec',
-        'replace',
-        'search',
-        'split',
-    ]);
+    const originalScript = script;
+    script = `(()=>{${script}})()`;
     try {
-        // Note: Extract variables from template literals like ${variable}
-        const templateRegex = /\$\{([a-zA-Z_$][a-zA-Z0-9_$]*)\}/g;
-        let match;
-        while ((match = templateRegex.exec(script)) !== null) {
-            const varName = match[1];
-            if (!exclude.has(varName)) {
-                variables.add(varName);
+        for (let i = 0; i < LOOP_LIMIT; i++)
+            try {
+                eval(script); // <- TODO: Use `JavascriptExecutionTools.execute` here
             }
-        }
-        // Note: Process the script to handle normal variable usage
-        const processedScript = script
-            .replace(/'(?:\\.|[^'\\])*'/g, "''") // <- Note: Remove string literals
-            .replace(/"(?:\\.|[^"\\])*"/g, '""')
-            .replace(/`(?:\\.|[^`\\])*`/g, '``')
-            .replace(/\/(?:\\.|[^/\\])*\/[gimsuy]*/g, '{}'); // <- Note: Remove regex literals
-        // Note: Find identifiers in function arguments
-        const funcArgRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/g;
-        const funcNames = new Set();
-        while ((match = funcArgRegex.exec(processedScript)) !== null) {
-            funcNames.add(match[1]);
-        }
-        // Find variable declarations to exclude them
-        const declaredVars = new Set();
-        const declRegex = /\b(const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
-        while ((match = declRegex.exec(processedScript)) !== null) {
-            declaredVars.add(match[2]);
-        }
-        // Note: Find identifiers in the script
-        const identifierRegex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
-        while ((match = identifierRegex.exec(processedScript)) !== null) {
-            const name = match[1];
-            // Add if not excluded, not a function name, and not a declared variable
-            if (!exclude.has(name) && !funcNames.has(name) && !declaredVars.has(name)) {
-                variables.add(name);
+            catch (error) {
+                if (!(error instanceof ReferenceError)) {
+                    throw error;
+                }
+                /*
+                Note: Parsing the error
+                      🌟 Most devices:
+                      [PipelineUrlError: thing is not defined]
+
+                      🍏 iPhone`s Safari:
+                      [PipelineUrlError: Can't find variable: thing]
+                */
+                let variableName = undefined;
+                if (error.message.startsWith(`Can't`)) {
+                    // 🍏 Case
+                    variableName = error.message.split(' ').pop();
+                }
+                else {
+                    // 🌟 Case
+                    variableName = error.message.split(' ').shift();
+                }
+                if (variableName === undefined) {
+                    throw error;
+                }
+                if (script.includes(variableName + '(')) {
+                    script = `const ${variableName} = ()=>'';` + script;
+                }
+                else {
+                    variables.add(variableName);
+                    script = `const ${variableName} = '';` + script;
+                }
             }
-        }
     }
     catch (error) {
         if (!(error instanceof Error)) {
             throw error;
         }
-        throw new ParseError(spaceTrim((block) => `
+        throw new ParseError(spaceTrim$1((block) => `
                     Can not extract variables from the script
                     ${block(error.stack || error.message)}
 
@@ -3761,7 +3702,7 @@ function extractVariablesFromScript(script) {
                     The script:
 
                     \`\`\`javascript
-                    ${block(script)}
+                    ${block(originalScript)}
                     \`\`\`
                 `));
     }
@@ -3782,19 +3723,24 @@ function extractVariablesFromScript(script) {
 function extractParameterNamesFromTask(task) {
     const { title, description, taskType, content, preparedContent, jokerParameterNames, foreach } = task;
     const parameterNames = new Set();
+    let contentParameters;
+    if (taskType !== 'SCRIPT_TASK') {
+        contentParameters = extractParameterNames(content);
+    }
+    else {
+        // TODO: What if script is not javascript?
+        // const { contentLanguage } = task;
+        // if (contentLanguage !== 'javascript') {
+        contentParameters = extractVariablesFromJavascript(content);
+    }
     for (const parameterName of [
         ...extractParameterNames(title),
         ...extractParameterNames(description || ''),
-        ...extractParameterNames(content),
+        ...contentParameters,
         ...extractParameterNames(preparedContent || ''),
     ]) {
         parameterNames.add(parameterName);
     }
-    if (taskType === 'SCRIPT_TASK') {
-        for (const parameterName of extractVariablesFromScript(content)) {
-            parameterNames.add(parameterName);
-        }
-    }
     for (const jokerName of jokerParameterNames || []) {
         parameterNames.add(jokerName);
     }