@workglow/tasks 0.0.85 → 0.0.87

package/dist/browser.js

@@ -6,132 +6,18 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/task/DebugLogTask.ts
-import { CreateWorkflow, Task, TaskRegistry, Workflow } from "@workglow/task-graph";
-var log_levels = ["dir", "log", "debug", "info", "warn", "error"];
-var DEFAULT_LOG_LEVEL = "log";
-var inputSchema = {
-  type: "object",
-  properties: {
-    console: {
-      title: "Message",
-      description: "The message to log"
-    },
-    log_level: {
-      type: "string",
-      enum: log_levels,
-      title: "Log Level",
-      description: "The log level to use",
-      default: DEFAULT_LOG_LEVEL
-    }
-  },
-  additionalProperties: false
-};
-var outputSchema = {
-  type: "object",
-  properties: {
-    console: {
-      title: "Messages",
-      description: "The messages logged by the task"
-    }
-  },
-  additionalProperties: false
-};
+// src/browser.ts
+import { TaskRegistry as TaskRegistry2 } from "@workglow/task-graph";
 
-class DebugLogTask extends Task {
-  static type = "DebugLogTask";
-  static category = "Utility";
-  static title = "Debug Log";
-  static description = "Logs messages to the console with configurable log levels for debugging task graphs";
-  static cacheable = false;
-  static inputSchema() {
-    return inputSchema;
-  }
-  static outputSchema() {
-    return outputSchema;
-  }
-  async executeReactive(input, output) {
-    const { log_level = DEFAULT_LOG_LEVEL, console: messages } = input;
-    if (log_level == "dir") {
-      console.dir(messages, { depth: null });
-    } else {
-      console[log_level](messages);
-    }
-    output.console = input.console;
-    return output;
-  }
-}
-TaskRegistry.registerTask(DebugLogTask);
-var debugLog = (input, config = {}) => {
-  const task = new DebugLogTask(input, config);
-  return task.run();
-};
-Workflow.prototype.debugLog = CreateWorkflow(DebugLogTask);
-// src/task/DelayTask.ts
+// src/task/FileLoaderTask.ts
 import {
   CreateWorkflow as CreateWorkflow2,
-  Task as Task2,
+  Task,
   TaskAbortedError,
-  TaskRegistry as TaskRegistry2,
   Workflow as Workflow2
 } from "@workglow/task-graph";
-import { sleep } from "@workglow/util";
-var inputSchema2 = {
-  type: "object",
-  properties: {
-    delay: {
-      type: "number",
-      title: "Delay (ms)",
-      default: 1
-    },
-    pass_through: {
-      title: "Pass Through",
-      description: "Pass through data to the output"
-    }
-  },
-  additionalProperties: false
-};
-var outputSchema2 = {
-  type: "object",
-  properties: {},
-  additionalProperties: true
-};
+import Papa from "papaparse";
 
-class DelayTask extends Task2 {
-  static type = "DelayTask";
-  static category = "Utility";
-  static title = "Delay";
-  static description = "Delays execution for a specified duration with progress tracking";
-  static inputSchema() {
-    return inputSchema2;
-  }
-  static outputSchema() {
-    return outputSchema2;
-  }
-  async execute(input, executeContext) {
-    const delay = input.delay ?? 0;
-    if (delay > 100) {
-      const iterations = Math.min(100, Math.floor(delay / 16));
-      const chunkSize = delay / iterations;
-      for (let i = 0;i < iterations; i++) {
-        if (executeContext.signal.aborted) {
-          throw new TaskAbortedError("Task aborted");
-        }
-        await sleep(chunkSize);
-        await executeContext.updateProgress(100 * i / iterations, `Delaying for ${delay}ms`);
-      }
-    } else {
-      await sleep(delay);
-    }
-    return input.pass_through;
-  }
-}
-TaskRegistry2.registerTask(DelayTask);
-var delay = (input, config = {}) => {
-  const task = new DelayTask(input, config);
-  return task.run();
-};
-Workflow2.prototype.delay = CreateWorkflow2(DelayTask);
 // src/task/FetchUrlTask.ts
 import {
   AbortSignalJobError,
@@ -140,14 +26,13 @@ import {
   RetryableJobError
 } from "@workglow/job-queue";
 import {
-  CreateWorkflow as CreateWorkflow3,
+  CreateWorkflow,
   JobQueueTask,
   TaskConfigurationError,
   TaskInvalidInputError,
-  TaskRegistry as TaskRegistry3,
-  Workflow as Workflow3
+  Workflow
 } from "@workglow/task-graph";
-var inputSchema3 = {
+var inputSchema = {
   type: "object",
   properties: {
     url: {
@@ -196,7 +81,7 @@ var inputSchema3 = {
   required: ["url"],
   additionalProperties: false
 };
-var outputSchema3 = {
+var outputSchema = {
   type: "object",
   properties: {
     json: {
@@ -356,10 +241,10 @@ class FetchUrlTask extends JobQueueTask {
   static description = "Fetches data from a URL with progress tracking and automatic retry handling";
   static hasDynamicSchemas = true;
   static inputSchema() {
-    return inputSchema3;
+    return inputSchema;
   }
   static outputSchema() {
-    return outputSchema3;
+    return outputSchema;
   }
   outputSchema() {
     const responseType = this.runInputData?.response_type ?? this.defaults?.response_type ?? null;
@@ -435,84 +320,665 @@ class FetchUrlTask extends JobQueueTask {
     }
   }
 }
-TaskRegistry3.registerTask(FetchUrlTask);
 var fetchUrl = async (input, config = {}) => {
-  const result = await new FetchUrlTask(input, config).run();
+  const result = await new FetchUrlTask({}, config).run(input);
   return result;
 };
-Workflow3.prototype.fetch = CreateWorkflow3(FetchUrlTask);
-// src/task/JavaScriptTask.ts
-import { CreateWorkflow as CreateWorkflow4, Task as Task3, TaskRegistry as TaskRegistry4, Workflow as Workflow4 } from "@workglow/task-graph";
+Workflow.prototype.fetch = CreateWorkflow(FetchUrlTask);
 
-// src/util/acorn.js
-var options;
-var input = "";
-var inputLen;
-var sourceFile;
-var parse = function(inpt, opts) {
-  input = String(inpt);
-  inputLen = input.length;
-  setOptions(opts);
-  initTokenState();
-  return parseTopLevel(options.program);
-};
-var defaultOptions = {
-  strictSemicolons: false,
-  allowTrailingCommas: true,
-  forbidReserved: false,
-  allowReturnOutsideFunction: false,
-  locations: false,
-  onComment: null,
-  ranges: false,
-  program: null,
-  sourceFile: null,
-  directSourceFile: null
+// src/task/FileLoaderTask.ts
+var inputSchema2 = {
+  type: "object",
+  properties: {
+    url: {
+      type: "string",
+      title: "URL",
+      description: "URL to load document from (http://, https://)",
+      format: "uri"
+    },
+    format: {
+      type: "string",
+      enum: ["text", "markdown", "json", "csv", "pdf", "image", "html", "auto"],
+      title: "Format",
+      description: "File format (auto-detected from URL if 'auto')",
+      default: "auto"
+    }
+  },
+  required: ["url"],
+  additionalProperties: false
 };
-function setOptions(opts) {
-  options = opts || {};
-  for (var opt in defaultOptions) {
-    if (!Object.prototype.hasOwnProperty.call(options, opt)) {
-      options[opt] = defaultOptions[opt];
+var outputSchema2 = {
+  type: "object",
+  properties: {
+    text: {
+      type: "string",
+      title: "Text",
+      description: "Text content (for text, markdown, html formats)"
+    },
+    json: {
+      title: "JSON",
+      description: "Parsed JSON object or array"
+    },
+    csv: {
+      type: "array",
+      title: "CSV",
+      description: "Parsed CSV data as array of objects"
+    },
+    image: {
+      type: "string",
+      title: "Image",
+      description: "Base64 data URL for image files",
+      format: "image:data-uri"
+    },
+    pdf: {
+      type: "string",
+      title: "PDF",
+      description: "Base64 data URL for PDF files"
+    },
+    metadata: {
+      type: "object",
+      properties: {
+        url: { type: "string" },
+        format: { type: "string" },
+        size: { type: "number" },
+        title: { type: "string" },
+        mimeType: { type: "string" }
+      },
+      additionalProperties: false,
+      title: "Metadata",
+      description: "File metadata"
     }
+  },
+  required: ["metadata"],
+  additionalProperties: false
+};
+
+class FileLoaderTask extends Task {
+  static type = "FileLoaderTask";
+  static category = "Document";
+  static title = "File Loader";
+  static description = "Load documents from URLs (http://, https://)";
+  static cacheable = true;
+  static inputSchema() {
+    return inputSchema2;
   }
-  sourceFile = options.sourceFile;
-}
-var getLineInfo = function(input2, offset) {
-  for (var line = 1, cur = 0;; ) {
-    lineBreak.lastIndex = cur;
-    var match = lineBreak.exec(input2);
-    if (match && match.index < offset) {
-      ++line;
-      cur = match.index + match[0].length;
-    } else {
-      break;
-    }
+  static outputSchema() {
+    return outputSchema2;
   }
-  return { line, column: offset - cur };
-};
-var tokPos = 0;
-var tokStart = 0;
-var tokEnd = 0;
-var tokStartLoc;
-var tokEndLoc;
-var tokType;
-var tokVal;
-var tokRegexpAllowed;
-var tokCurLine;
-var tokLineStart;
-var lastStart = 0;
-var lastEnd = 0;
-var lastEndLoc;
-var inFunction;
-var labels;
-var strict;
-function raise(pos, message) {
-  var loc = getLineInfo(input, pos);
-  message += " (" + loc.line + ":" + loc.column + ")";
-  var err = new SyntaxError(message);
-  err.pos = pos;
-  err.loc = loc;
-  err.raisedAt = tokPos;
+  async execute(input, context) {
+    const { url, format = "auto" } = input;
+    if (context.signal.aborted) {
+      throw new TaskAbortedError("Task aborted");
+    }
+    await context.updateProgress(0, "Detecting file format");
+    const detectedFormat = this.detectFormat(url, format);
+    const responseType = this.detectResponseType(detectedFormat);
+    if (context.signal.aborted) {
+      throw new TaskAbortedError("Task aborted");
+    }
+    await context.updateProgress(10, `Fetching ${detectedFormat} file from ${url}`);
+    const fetchTask = context.own(new FetchUrlTask({
+      url,
+      response_type: responseType,
+      queue: false
+    }));
+    const response = await fetchTask.run();
+    if (context.signal.aborted) {
+      throw new TaskAbortedError("Task aborted");
+    }
+    await context.updateProgress(60, "Parsing file content");
+    const title = url.split("/").pop() || url;
+    const { text, json, csv, image, pdf, size, mimeType } = await this.parseResponse(response, url, detectedFormat);
+    if (context.signal.aborted) {
+      throw new TaskAbortedError("Task aborted");
+    }
+    await context.updateProgress(100, "File loaded successfully");
+    return {
+      text,
+      json,
+      csv,
+      image,
+      pdf,
+      metadata: {
+        url,
+        format: detectedFormat,
+        size,
+        title,
+        mimeType
+      }
+    };
+  }
+  parseJsonContent(content) {
+    return JSON.parse(content);
+  }
+  parseCsvContent(content) {
+    try {
+      const result = Papa.parse(content, {
+        header: true,
+        skipEmptyLines: true,
+        transformHeader: (header) => header.trim()
+      });
+      return result.data;
+    } catch (error) {
+      throw new Error(`Failed to parse CSV: ${error}`);
+    }
+  }
+  async parseResponse(response, url, detectedFormat) {
+    const responseMimeType = response.metadata?.contentType || "";
+    if (detectedFormat === "json") {
+      if (!response.json) {
+        throw new Error(`Failed to load JSON from ${url}`);
+      }
+      const jsonData = response.json;
+      const content2 = JSON.stringify(jsonData, null, 2);
+      return {
+        text: undefined,
+        json: jsonData,
+        csv: undefined,
+        image: undefined,
+        pdf: undefined,
+        size: content2.length,
+        mimeType: responseMimeType || "application/json"
+      };
+    }
+    if (detectedFormat === "csv") {
+      const content2 = response.text || "";
+      if (!content2) {
+        throw new Error(`Failed to load CSV from ${url}`);
+      }
+      const csvData = this.parseCsvContent(content2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: csvData,
+        image: undefined,
+        pdf: undefined,
+        size: content2.length,
+        mimeType: responseMimeType || "text/csv"
+      };
+    }
+    if (detectedFormat === "image") {
+      if (!response.blob) {
+        throw new Error(`Failed to load image from ${url}`);
+      }
+      const blob = response.blob;
+      const mimeType2 = responseMimeType || (blob.type && blob.type !== "" ? blob.type : this.getImageMimeType(url));
+      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: imageData,
+        pdf: undefined,
+        size: blob.size,
+        mimeType: mimeType2
+      };
+    }
+    if (detectedFormat === "pdf") {
+      if (!response.blob) {
+        throw new Error(`Failed to load PDF from ${url}`);
+      }
+      const blob = response.blob;
+      const mimeType2 = responseMimeType || "application/pdf";
+      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
+      return {
+        text: undefined,
+        json: undefined,
+        csv: undefined,
+        image: undefined,
+        pdf: pdfData,
+        size: blob.size,
+        mimeType: mimeType2
+      };
+    }
+    const content = response.text || "";
+    if (!content) {
+      throw new Error(`Failed to load content from ${url}`);
+    }
+    const mimeType = responseMimeType || (detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain");
+    return {
+      text: content,
+      json: undefined,
+      csv: undefined,
+      image: undefined,
+      pdf: undefined,
+      size: content.length,
+      mimeType
+    };
+  }
+  detectResponseType(detectedFormat) {
+    let responseType = "text";
+    if (detectedFormat === "json") {
+      responseType = "json";
+    } else if (detectedFormat === "image" || detectedFormat === "pdf") {
+      responseType = "blob";
+    } else if (detectedFormat === "csv" || detectedFormat === "text" || detectedFormat === "markdown" || detectedFormat === "html") {
+      responseType = "text";
+    }
+    return responseType;
+  }
+  detectFormat(url, format) {
+    if (format === "auto") {
+      const urlLower = url.toLowerCase();
+      if (urlLower.endsWith(".md") || urlLower.endsWith(".markdown")) {
+        return "markdown";
+      } else if (urlLower.endsWith(".json")) {
+        return "json";
+      } else if (urlLower.endsWith(".csv")) {
+        return "csv";
+      } else if (urlLower.endsWith(".pdf")) {
+        return "pdf";
+      } else if (urlLower.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg|ico)$/)) {
+        return "image";
+      } else if (urlLower.endsWith(".html") || urlLower.endsWith(".htm")) {
+        return "html";
+      } else {
+        return "text";
+      }
+    }
+    return format;
+  }
+  getImageMimeType(url) {
+    const urlLower = url.toLowerCase();
+    if (urlLower.endsWith(".png"))
+      return "image/png";
+    if (urlLower.endsWith(".jpg") || urlLower.endsWith(".jpeg"))
+      return "image/jpeg";
+    if (urlLower.endsWith(".gif"))
+      return "image/gif";
+    if (urlLower.endsWith(".webp"))
+      return "image/webp";
+    if (urlLower.endsWith(".bmp"))
+      return "image/bmp";
+    if (urlLower.endsWith(".svg"))
+      return "image/svg+xml";
+    if (urlLower.endsWith(".ico"))
+      return "image/x-icon";
+    return "image/jpeg";
+  }
+  async blobToBase64DataURL(blob, mimeType) {
+    if (typeof Buffer !== "undefined") {
+      const arrayBuffer = await blob.arrayBuffer();
+      const buffer = Buffer.from(arrayBuffer);
+      return `data:${mimeType};base64,${buffer.toString("base64")}`;
+    }
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader;
+      reader.onloadend = () => {
+        const result = reader.result;
+        if (result.startsWith("data:;base64,")) {
+          resolve(`data:${mimeType};base64,${result.substring(13)}`);
+        } else {
+          resolve(result);
+        }
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+}
+var fileLoader = (input, config) => {
+  return new FileLoaderTask({}, config).run(input);
+};
+Workflow2.prototype.fileLoader = CreateWorkflow2(FileLoaderTask);
+
+// src/task/ArrayTask.ts
+import {
+  uuid4
+} from "@workglow/util";
+import {
+  GraphAsTask,
+  GraphAsTaskRunner,
+  PROPERTY_ARRAY,
+  TaskGraph
+} from "@workglow/task-graph";
+var TypeReplicateArray = (type, annotations = {}) => ({
+  oneOf: [type, { type: "array", items: type }],
+  title: type.title,
+  description: type.description,
+  ...type.format ? { format: type.format } : {},
+  ...annotations,
+  "x-replicate": true
+});
+
+class ArrayTask extends GraphAsTask {
+  static type = "ArrayTask";
+  static compoundMerge = PROPERTY_ARRAY;
+  inputSchema() {
+    return this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.constructor.outputSchema();
+  }
+  executeMerge(_input, output) {
+    return output;
+  }
+  regenerateGraph() {
+    const arrayInputs = new Map;
+    let hasArrayInputs = false;
+    const inputSchema3 = this.inputSchema();
+    if (typeof inputSchema3 !== "boolean") {
+      const keys = Object.keys(inputSchema3.properties || {});
+      for (const inputId of keys) {
+        const inputValue = this.runInputData[inputId];
+        const inputDef = inputSchema3.properties?.[inputId];
+        if (typeof inputDef === "object" && inputDef !== null && "x-replicate" in inputDef && inputDef["x-replicate"] === true && Array.isArray(inputValue) && inputValue.length > 1) {
+          arrayInputs.set(inputId, inputValue);
+          hasArrayInputs = true;
+        }
+      }
+    }
+    this.subGraph = new TaskGraph;
+    if (!hasArrayInputs) {
+      super.regenerateGraph();
+      return;
+    }
+    const inputIds = Array.from(arrayInputs.keys());
+    const inputObject = Object.fromEntries(arrayInputs);
+    const combinations = this.generateCombinations(inputObject, inputIds);
+    const tasks = combinations.map((combination) => {
+      const { id, name, ...rest } = this.config;
+      const task = new this.constructor({ ...this.defaults, ...this.runInputData, ...combination }, { ...rest, id: `${id}_${uuid4()}` });
+      return task;
+    });
+    this.subGraph.addTasks(tasks);
+    super.regenerateGraph();
+  }
+  generateCombinations(input, inputMakeArray) {
+    const arraysToCombine = inputMakeArray.map((key) => Array.isArray(input[key]) ? input[key] : []);
+    const indices = new Array(arraysToCombine.length).fill(0);
+    const combinations = [];
+    let done = false;
+    while (!done) {
+      combinations.push([...indices]);
+      for (let i = indices.length - 1;i >= 0; i--) {
+        if (++indices[i] < arraysToCombine[i].length)
+          break;
+        if (i === 0)
+          done = true;
+        else
+          indices[i] = 0;
+      }
+    }
+    const combos = combinations.map((combination) => {
+      const result = { ...input };
+      combination.forEach((valueIndex, arrayIndex) => {
+        const key = inputMakeArray[arrayIndex];
+        if (Array.isArray(input[key]))
+          result[key] = input[key][valueIndex];
+      });
+      return result;
+    });
+    return combos;
+  }
+  toJSON() {
+    const { subgraph, ...result } = super.toJSON();
+    return result;
+  }
+  toDependencyJSON() {
+    const { subtasks, ...result } = super.toDependencyJSON();
+    return result;
+  }
+  get runner() {
+    if (!this._runner) {
+      this._runner = new ArrayTaskRunner(this);
+    }
+    return this._runner;
+  }
+}
+
+class ArrayTaskRunner extends GraphAsTaskRunner {
+  async executeTaskChildren(_input) {
+    return super.executeTaskChildren({});
+  }
+  async executeTaskReactive(input, output) {
+    await super.executeTaskReactive(input, output);
+    if (this.task.hasChildren()) {
+      this.task.runOutputData = this.task.executeMerge(input, this.task.runOutputData);
+    }
+    return this.task.runOutputData;
+  }
+  async executeTask(input) {
+    await super.executeTask(input);
+    if (this.task.hasChildren()) {
+      this.task.runOutputData = this.task.executeMerge(input, this.task.runOutputData);
+    }
+    return this.task.runOutputData;
+  }
+}
+// src/task/DebugLogTask.ts
+import { CreateWorkflow as CreateWorkflow3, Task as Task2, Workflow as Workflow3 } from "@workglow/task-graph";
+var log_levels = ["dir", "log", "debug", "info", "warn", "error"];
+var DEFAULT_LOG_LEVEL = "log";
+var inputSchema3 = {
+  type: "object",
+  properties: {
+    console: {
+      title: "Message",
+      description: "The message to log"
+    },
+    log_level: {
+      type: "string",
+      enum: log_levels,
+      title: "Log Level",
+      description: "The log level to use",
+      default: DEFAULT_LOG_LEVEL
+    }
+  },
+  additionalProperties: false
+};
+var outputSchema3 = {
+  type: "object",
+  properties: {
+    console: {
+      title: "Messages",
+      description: "The messages logged by the task"
+    }
+  },
+  additionalProperties: false
+};
+
+class DebugLogTask extends Task2 {
+  static type = "DebugLogTask";
+  static category = "Utility";
+  static title = "Debug Log";
+  static description = "Logs messages to the console with configurable log levels for debugging task graphs";
+  static cacheable = false;
+  static inputSchema() {
+    return inputSchema3;
+  }
+  static outputSchema() {
+    return outputSchema3;
+  }
+  async executeReactive(input, output) {
+    const { log_level = DEFAULT_LOG_LEVEL, console: messages } = input;
+    if (log_level == "dir") {
+      console.dir(messages, { depth: null });
+    } else {
+      console[log_level](messages);
+    }
+    output.console = input.console;
+    return output;
+  }
+}
+var debugLog = (input, config = {}) => {
+  const task = new DebugLogTask({}, config);
+  return task.run(input);
+};
+Workflow3.prototype.debugLog = CreateWorkflow3(DebugLogTask);
+// src/task/DelayTask.ts
+import {
+  CreateWorkflow as CreateWorkflow4,
+  Task as Task3,
+  TaskAbortedError as TaskAbortedError2,
+  Workflow as Workflow4
+} from "@workglow/task-graph";
+import { sleep } from "@workglow/util";
+var inputSchema4 = {
+  type: "object",
+  properties: {
+    delay: {
+      type: "number",
+      title: "Delay (ms)",
+      default: 1
+    },
+    pass_through: {
+      title: "Pass Through",
+      description: "Pass through data to the output"
+    }
+  },
+  additionalProperties: false
+};
+var outputSchema4 = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
+
+class DelayTask extends Task3 {
+  static type = "DelayTask";
+  static category = "Utility";
+  static title = "Delay";
+  static description = "Delays execution for a specified duration with progress tracking";
+  static inputSchema() {
+    return inputSchema4;
+  }
+  static outputSchema() {
+    return outputSchema4;
+  }
+  async execute(input, executeContext) {
+    const delay = input.delay ?? 0;
+    if (delay > 100) {
+      const iterations = Math.min(100, Math.floor(delay / 16));
+      const chunkSize = delay / iterations;
+      for (let i = 0;i < iterations; i++) {
+        if (executeContext.signal.aborted) {
+          throw new TaskAbortedError2("Task aborted");
+        }
+        await sleep(chunkSize);
+        await executeContext.updateProgress(100 * i / iterations, `Delaying for ${delay}ms`);
+      }
+    } else {
+      await sleep(delay);
+    }
+    return input.pass_through;
+  }
+}
+var delay = (input, config = {}) => {
+  const task = new DelayTask({}, config);
+  return task.run(input);
+};
+Workflow4.prototype.delay = CreateWorkflow4(DelayTask);
+// src/task/InputTask.ts
+import { CreateWorkflow as CreateWorkflow5, Task as Task4, Workflow as Workflow5 } from "@workglow/task-graph";
+
+class InputTask extends Task4 {
+  static type = "InputTask";
+  static category = "Flow Control";
+  static title = "Input";
+  static description = "Starts the workflow";
+  static hasDynamicSchemas = true;
+  static cacheable = false;
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  static outputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
+  }
+  inputSchema() {
+    return this.config?.extras?.inputSchema ?? this.constructor.inputSchema();
+  }
+  outputSchema() {
+    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
+  }
+  async execute(input) {
+    return input;
+  }
+  async executeReactive(input) {
+    return input;
+  }
+}
+Workflow5.prototype.input = CreateWorkflow5(InputTask);
+// src/task/JavaScriptTask.ts
+import { CreateWorkflow as CreateWorkflow6, Task as Task5, Workflow as Workflow6 } from "@workglow/task-graph";
+
+// src/util/acorn.js
+var options;
+var input = "";
+var inputLen;
+var sourceFile;
+var parse = function(inpt, opts) {
+  input = String(inpt);
+  inputLen = input.length;
+  setOptions(opts);
+  initTokenState();
+  return parseTopLevel(options.program);
+};
+var defaultOptions = {
+  strictSemicolons: false,
+  allowTrailingCommas: true,
+  forbidReserved: false,
+  allowReturnOutsideFunction: false,
+  locations: false,
+  onComment: null,
+  ranges: false,
+  program: null,
+  sourceFile: null,
+  directSourceFile: null
+};
+function setOptions(opts) {
+  options = opts || {};
+  for (var opt in defaultOptions) {
+    if (!Object.prototype.hasOwnProperty.call(options, opt)) {
+      options[opt] = defaultOptions[opt];
+    }
+  }
+  sourceFile = options.sourceFile;
+}
+var getLineInfo = function(input2, offset) {
+  for (var line = 1, cur = 0;; ) {
+    lineBreak.lastIndex = cur;
+    var match = lineBreak.exec(input2);
+    if (match && match.index < offset) {
+      ++line;
+      cur = match.index + match[0].length;
+    } else {
+      break;
+    }
+  }
+  return { line, column: offset - cur };
+};
+var tokPos = 0;
+var tokStart = 0;
+var tokEnd = 0;
+var tokStartLoc;
+var tokEndLoc;
+var tokType;
+var tokVal;
+var tokRegexpAllowed;
+var tokCurLine;
+var tokLineStart;
+var lastStart = 0;
+var lastEnd = 0;
+var lastEndLoc;
+var inFunction;
+var labels;
+var strict;
+function raise(pos, message) {
+  var loc = getLineInfo(input, pos);
+  message += " (" + loc.line + ":" + loc.column + ")";
+  var err = new SyntaxError(message);
+  err.pos = pos;
+  err.loc = loc;
+  err.raisedAt = tokPos;
   throw err;
 }
 var empty = [];
@@ -4905,7 +5371,7 @@ Interpreter["VALUE_IN_DESCRIPTOR"] = Interpreter.VALUE_IN_DESCRIPTOR;
 Interpreter["Status"] = Interpreter.Status;
 
 // src/task/JavaScriptTask.ts
-var inputSchema4 = {
+var inputSchema5 = {
   type: "object",
   properties: {
     javascript_code: {
@@ -4919,7 +5385,7 @@ var inputSchema4 = {
   required: ["javascript_code"],
   additionalProperties: true
 };
-var outputSchema4 = {
+var outputSchema5 = {
   type: "object",
   properties: {
     output: {
@@ -4931,16 +5397,16 @@ var outputSchema4 = {
   additionalProperties: false
 };
 
-class JavaScriptTask extends Task3 {
+class JavaScriptTask extends Task5 {
   static type = "JavaScriptTask";
   static category = "Utility";
   static title = "JavaScript Interpreter";
   static description = "Executes JavaScript code in a sandboxed interpreter environment";
   static inputSchema() {
-    return inputSchema4;
+    return inputSchema5;
   }
   static outputSchema() {
-    return outputSchema4;
+    return outputSchema5;
   }
   async executeReactive(input2, output) {
     if (input2.javascript_code) {
@@ -4959,22 +5425,20 @@ class JavaScriptTask extends Task3 {
     return output;
   }
 }
-TaskRegistry4.registerTask(JavaScriptTask);
 var javaScript = (input2, config = {}) => {
-  return new JavaScriptTask(input2, config).run();
+  return new JavaScriptTask({}, config).run(input2);
 };
-Workflow4.prototype.javaScript = CreateWorkflow4(JavaScriptTask);
+Workflow6.prototype.javaScript = CreateWorkflow6(JavaScriptTask);
 // src/task/JsonTask.ts
 import {
   createGraphFromDependencyJSON,
-  CreateWorkflow as CreateWorkflow5,
+  CreateWorkflow as CreateWorkflow7,
   Dataflow,
-  GraphAsTask,
+  GraphAsTask as GraphAsTask2,
   TaskConfigurationError as TaskConfigurationError2,
-  TaskRegistry as TaskRegistry5,
-  Workflow as Workflow5
+  Workflow as Workflow7
 } from "@workglow/task-graph";
-var inputSchema5 = {
+var inputSchema6 = {
   type: "object",
   properties: {
     json: {
@@ -4985,7 +5449,7 @@ var inputSchema5 = {
   },
   additionalProperties: false
 };
-var outputSchema5 = {
+var outputSchema6 = {
   type: "object",
   properties: {
     output: {
@@ -4996,14 +5460,16 @@ var outputSchema5 = {
   additionalProperties: false
 };
 
-class JsonTask extends GraphAsTask {
+class JsonTask extends GraphAsTask2 {
   static type = "JsonTask";
   static category = "Hidden";
+  static title = "JSON Task";
+  static description = "A task that creates and manages task graphs from JSON configurations";
   static inputSchema() {
-    return inputSchema5;
+    return inputSchema6;
   }
   static outputSchema() {
-    return outputSchema5;
+    return outputSchema6;
   }
   regenerateGraph() {
     if (!this.runInputData.json)
@@ -5031,21 +5497,19 @@ class JsonTask extends GraphAsTask {
     super.regenerateGraph();
   }
 }
-TaskRegistry5.registerTask(JsonTask);
 var json = (input2, config = {}) => {
-  return new JsonTask(input2, config).run();
+  return new JsonTask({}, config).run(input2);
 };
-Workflow5.prototype.json = CreateWorkflow5(JsonTask);
+Workflow7.prototype.json = CreateWorkflow7(JsonTask);
 // src/task/LambdaTask.ts
 import {
-  CreateWorkflow as CreateWorkflow6,
+  CreateWorkflow as CreateWorkflow8,
   DATAFLOW_ALL_PORTS,
-  Task as Task4,
+  Task as Task6,
   TaskConfigurationError as TaskConfigurationError3,
-  TaskRegistry as TaskRegistry6,
-  Workflow as Workflow6
+  Workflow as Workflow8
 } from "@workglow/task-graph";
-var inputSchema6 = {
+var inputSchema7 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -5055,7 +5519,7 @@ var inputSchema6 = {
   },
   additionalProperties: true
 };
-var outputSchema6 = {
+var outputSchema7 = {
   type: "object",
   properties: {
     [DATAFLOW_ALL_PORTS]: {
@@ -5066,15 +5530,17 @@ var outputSchema6 = {
   additionalProperties: true
 };
 
-class LambdaTask extends Task4 {
+class LambdaTask extends Task6 {
   static type = "LambdaTask";
+  static title = "Lambda Task";
+  static description = "A task that wraps a provided function and its input";
   static category = "Hidden";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema6;
+    return inputSchema7;
   }
   static outputSchema() {
-    return outputSchema6;
+    return outputSchema7;
   }
   constructor(input2 = {}, config = {}) {
     if (!config.execute && !config.executeReactive) {
@@ -5095,7 +5561,6 @@ class LambdaTask extends Task4 {
     return output;
   }
 }
-TaskRegistry6.registerTask(LambdaTask);
 function process(value) {
   if (typeof value === "string")
     return `Processed: ${value}`;
@@ -5113,20 +5578,15 @@ function lambda(input2, config) {
   const task = new LambdaTask(input2, config);
   return task.run();
 }
-Workflow6.prototype.lambda = CreateWorkflow6(LambdaTask);
+Workflow8.prototype.lambda = CreateWorkflow8(LambdaTask);
 // src/task/MergeTask.ts
-import {
-  CreateWorkflow as CreateWorkflow7,
-  Task as Task5,
-  TaskRegistry as TaskRegistry7,
-  Workflow as Workflow7
-} from "@workglow/task-graph";
-var inputSchema7 = {
+import { CreateWorkflow as CreateWorkflow9, Task as Task7, Workflow as Workflow9 } from "@workglow/task-graph";
+var inputSchema8 = {
   type: "object",
   properties: {},
   additionalProperties: true
 };
-var outputSchema7 = {
+var outputSchema8 = {
   type: "object",
   properties: {
     output: {
@@ -5138,390 +5598,147 @@ var outputSchema7 = {
   additionalProperties: false
 };
 
-class MergeTask extends Task5 {
+class MergeTask extends Task7 {
   static type = "MergeTask";
   static category = "Utility";
-  static title = "Merge";
-  static description = "Merges multiple inputs into a single array output";
-  static cacheable = true;
-  static inputSchema() {
-    return inputSchema7;
-  }
-  static outputSchema() {
-    return outputSchema7;
-  }
-  async execute(input2, context) {
-    const keys = Object.keys(input2).sort();
-    const values = keys.map((key) => input2[key]);
-    return {
-      output: values
-    };
-  }
-}
-TaskRegistry7.registerTask(MergeTask);
-var merge = (input2, config = {}) => {
-  const task = new MergeTask(input2, config);
-  return task.run();
-};
-Workflow7.prototype.merge = CreateWorkflow7(MergeTask);
-// src/task/SplitTask.ts
-import { CreateWorkflow as CreateWorkflow8, Task as Task6, TaskRegistry as TaskRegistry8, Workflow as Workflow8 } from "@workglow/task-graph";
-var inputSchema8 = {
-  type: "object",
-  properties: {
-    input: {
-      title: "Single Input",
-      description: "A single value to output"
-    }
-  },
-  additionalProperties: false
-};
-var outputSchema8 = {
-  type: "object",
-  properties: {},
-  additionalProperties: true
-};
-
-class SplitTask extends Task6 {
-  static type = "SplitTask";
-  static category = "Utility";
-  static title = "Split";
-  static description = "Splits an array into individual outputs, creating one output per element";
-  static hasDynamicSchemas = true;
-  static cacheable = false;
-  static inputSchema() {
-    return inputSchema8;
-  }
-  static outputSchema() {
-    return outputSchema8;
-  }
-  outputSchema() {
-    return outputSchema8;
-  }
-  async executeReactive(input2) {
-    const inputValue = input2.input;
-    const output = {};
-    if (Array.isArray(inputValue)) {
-      inputValue.forEach((item, index) => {
-        output[`output_${index}`] = item;
-      });
-    } else {
-      output.output_0 = inputValue;
-    }
-    return output;
-  }
-}
-TaskRegistry8.registerTask(SplitTask);
-var split = (input2, config = {}) => {
-  const task = new SplitTask(input2, config);
-  return task.run();
-};
-Workflow8.prototype.split = CreateWorkflow8(SplitTask);
-// src/task/FileLoaderTask.ts
-import {
-  CreateWorkflow as CreateWorkflow9,
-  Task as Task7,
-  TaskAbortedError as TaskAbortedError2,
-  TaskRegistry as TaskRegistry9,
-  Workflow as Workflow9
-} from "@workglow/task-graph";
-import { parse as parse2 } from "csv-parse/sync";
-var inputSchema9 = {
-  type: "object",
-  properties: {
-    url: {
-      type: "string",
-      title: "URL",
-      description: "URL to load document from (http://, https://)",
-      format: "uri"
-    },
-    format: {
-      type: "string",
-      enum: ["text", "markdown", "json", "csv", "pdf", "image", "html", "auto"],
-      title: "Format",
-      description: "File format (auto-detected from URL if 'auto')",
-      default: "auto"
-    }
-  },
-  required: ["url"],
-  additionalProperties: false
-};
-var outputSchema9 = {
-  type: "object",
-  properties: {
-    text: {
-      type: "string",
-      title: "Text",
-      description: "Text content (for text, markdown, html formats)"
-    },
-    json: {
-      title: "JSON",
-      description: "Parsed JSON object or array"
-    },
-    csv: {
-      type: "array",
-      title: "CSV",
-      description: "Parsed CSV data as array of objects"
-    },
-    image: {
-      type: "string",
-      title: "Image",
-      description: "Base64 data URL for image files",
-      format: "image:data-uri"
-    },
-    pdf: {
-      type: "string",
-      title: "PDF",
-      description: "Base64 data URL for PDF files"
-    },
-    metadata: {
-      type: "object",
-      properties: {
-        url: { type: "string" },
-        format: { type: "string" },
-        size: { type: "number" },
-        title: { type: "string" },
-        mimeType: { type: "string" }
-      },
-      additionalProperties: false,
-      title: "Metadata",
-      description: "File metadata"
-    }
-  },
-  required: ["metadata"],
-  additionalProperties: false
-};
-
-class FileLoaderTask extends Task7 {
-  static type = "FileLoaderTask";
-  static category = "Document";
-  static title = "File Loader";
-  static description = "Load documents from URLs (http://, https://)";
+  static title = "Merge";
+  static description = "Merges multiple inputs into a single array output";
   static cacheable = true;
   static inputSchema() {
-    return inputSchema9;
+    return inputSchema8;
   }
   static outputSchema() {
-    return outputSchema9;
+    return outputSchema8;
   }
   async execute(input2, context) {
-    const { url, format = "auto" } = input2;
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(0, "Detecting file format");
-    const detectedFormat = this.detectFormat(url, format);
-    const responseType = this.detectResponseType(detectedFormat);
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(10, `Fetching ${detectedFormat} file from ${url}`);
-    const fetchTask = context.own(new FetchUrlTask({
-      url,
-      response_type: responseType,
-      queue: false
-    }));
-    const response = await fetchTask.run();
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(60, "Parsing file content");
-    const title = url.split("/").pop() || url;
-    const { text, json: json2, csv, image, pdf, size, mimeType } = await this.parseResponse(response, url, detectedFormat);
-    if (context.signal.aborted) {
-      throw new TaskAbortedError2("Task aborted");
-    }
-    await context.updateProgress(100, "File loaded successfully");
+    const keys = Object.keys(input2).sort();
+    const values = keys.map((key) => input2[key]);
     return {
-      text,
-      json: json2,
-      csv,
-      image,
-      pdf,
-      metadata: {
-        url,
-        format: detectedFormat,
-        size,
-        title,
-        mimeType
-      }
+      output: values
     };
   }
-  parseJsonContent(content) {
-    return JSON.parse(content);
-  }
-  parseCsvContent(content) {
-    try {
-      return parse2(content, {
-        columns: true,
-        skip_empty_lines: true,
-        trim: true
-      });
-    } catch (error) {
-      throw new Error(`Failed to parse CSV: ${error}`);
-    }
+}
+var merge = (input2, config = {}) => {
+  const task = new MergeTask({}, config);
+  return task.run(input2);
+};
+Workflow9.prototype.merge = CreateWorkflow9(MergeTask);
+// src/task/OutputTask.ts
+import { CreateWorkflow as CreateWorkflow10, Task as Task8, Workflow as Workflow10 } from "@workglow/task-graph";
+
+class OutputTask extends Task8 {
+  static type = "OutputTask";
+  static category = "Flow Control";
+  static title = "Output";
+  static description = "Ends the workflow";
+  static hasDynamicSchemas = true;
+  static cacheable = false;
+  static inputSchema() {
+    return {
+      type: "object",
+      properties: {},
+      additionalProperties: true
+    };
   }
-  async parseResponse(response, url, detectedFormat) {
-    const responseMimeType = response.metadata?.contentType || "";
-    if (detectedFormat === "json") {
-      if (!response.json) {
-        throw new Error(`Failed to load JSON from ${url}`);
-      }
-      const jsonData = response.json;
-      const content2 = JSON.stringify(jsonData, null, 2);
-      return {
-        text: undefined,
-        json: jsonData,
-        csv: undefined,
-        image: undefined,
-        pdf: undefined,
-        size: content2.length,
-        mimeType: responseMimeType || "application/json"
-      };
-    }
-    if (detectedFormat === "csv") {
-      const content2 = response.text || "";
-      if (!content2) {
-        throw new Error(`Failed to load CSV from ${url}`);
-      }
-      const csvData = this.parseCsvContent(content2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: csvData,
-        image: undefined,
-        pdf: undefined,
-        size: content2.length,
-        mimeType: responseMimeType || "text/csv"
-      };
-    }
-    if (detectedFormat === "image") {
-      if (!response.blob) {
-        throw new Error(`Failed to load image from ${url}`);
-      }
-      const blob = response.blob;
-      const mimeType2 = responseMimeType || (blob.type && blob.type !== "" ? blob.type : this.getImageMimeType(url));
-      const imageData = await this.blobToBase64DataURL(blob, mimeType2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: imageData,
-        pdf: undefined,
-        size: blob.size,
-        mimeType: mimeType2
-      };
-    }
-    if (detectedFormat === "pdf") {
-      if (!response.blob) {
-        throw new Error(`Failed to load PDF from ${url}`);
-      }
-      const blob = response.blob;
-      const mimeType2 = responseMimeType || "application/pdf";
-      const pdfData = await this.blobToBase64DataURL(blob, mimeType2);
-      return {
-        text: undefined,
-        json: undefined,
-        csv: undefined,
-        image: undefined,
-        pdf: pdfData,
-        size: blob.size,
-        mimeType: mimeType2
-      };
-    }
-    const content = response.text || "";
-    if (!content) {
-      throw new Error(`Failed to load content from ${url}`);
-    }
-    const mimeType = responseMimeType || (detectedFormat === "markdown" ? "text/markdown" : detectedFormat === "html" ? "text/html" : "text/plain");
+  static outputSchema() {
     return {
-      text: content,
-      json: undefined,
-      csv: undefined,
-      image: undefined,
-      pdf: undefined,
-      size: content.length,
-      mimeType
+      type: "object",
+      properties: {},
+      additionalProperties: true
     };
   }
-  detectResponseType(detectedFormat) {
-    let responseType = "text";
-    if (detectedFormat === "json") {
-      responseType = "json";
-    } else if (detectedFormat === "image" || detectedFormat === "pdf") {
-      responseType = "blob";
-    } else if (detectedFormat === "csv" || detectedFormat === "text" || detectedFormat === "markdown" || detectedFormat === "html") {
-      responseType = "text";
-    }
-    return responseType;
+  inputSchema() {
+    return this.config?.extras?.inputSchema ?? this.constructor.inputSchema();
   }
-  detectFormat(url, format) {
-    if (format === "auto") {
-      const urlLower = url.toLowerCase();
-      if (urlLower.endsWith(".md") || urlLower.endsWith(".markdown")) {
-        return "markdown";
-      } else if (urlLower.endsWith(".json")) {
-        return "json";
-      } else if (urlLower.endsWith(".csv")) {
-        return "csv";
-      } else if (urlLower.endsWith(".pdf")) {
-        return "pdf";
-      } else if (urlLower.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg|ico)$/)) {
-        return "image";
-      } else if (urlLower.endsWith(".html") || urlLower.endsWith(".htm")) {
-        return "html";
-      } else {
-        return "text";
-      }
+  outputSchema() {
+    return this.config?.extras?.outputSchema ?? this.constructor.outputSchema();
+  }
+  async execute(input2) {
+    return input2;
+  }
+  async executeReactive(input2) {
+    return input2;
+  }
+}
+Workflow10.prototype.output = CreateWorkflow10(OutputTask);
+// src/task/SplitTask.ts
+import { CreateWorkflow as CreateWorkflow11, Task as Task9, Workflow as Workflow11 } from "@workglow/task-graph";
+var inputSchema9 = {
+  type: "object",
+  properties: {
+    input: {
+      title: "Single Input",
+      description: "A single value to output"
     }
-    return format;
+  },
+  additionalProperties: false
+};
+var outputSchema9 = {
+  type: "object",
+  properties: {},
+  additionalProperties: true
+};
+
+class SplitTask extends Task9 {
+  static type = "SplitTask";
+  static category = "Utility";
+  static title = "Split";
+  static description = "Splits an array into individual outputs, creating one output per element";
+  static hasDynamicSchemas = true;
+  static cacheable = false;
+  static inputSchema() {
+    return inputSchema9;
   }
-  getImageMimeType(url) {
-    const urlLower = url.toLowerCase();
-    if (urlLower.endsWith(".png"))
-      return "image/png";
-    if (urlLower.endsWith(".jpg") || urlLower.endsWith(".jpeg"))
-      return "image/jpeg";
-    if (urlLower.endsWith(".gif"))
-      return "image/gif";
-    if (urlLower.endsWith(".webp"))
-      return "image/webp";
-    if (urlLower.endsWith(".bmp"))
-      return "image/bmp";
-    if (urlLower.endsWith(".svg"))
-      return "image/svg+xml";
-    if (urlLower.endsWith(".ico"))
-      return "image/x-icon";
-    return "image/jpeg";
+  static outputSchema() {
+    return outputSchema9;
   }
-  async blobToBase64DataURL(blob, mimeType) {
-    if (typeof Buffer !== "undefined") {
-      const arrayBuffer = await blob.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-      return `data:${mimeType};base64,${buffer.toString("base64")}`;
+  outputSchema() {
+    return outputSchema9;
+  }
+  async executeReactive(input2) {
+    const inputValue = input2.input;
+    const output = {};
+    if (Array.isArray(inputValue)) {
+      inputValue.forEach((item, index) => {
+        output[`output_${index}`] = item;
+      });
+    } else {
+      output.output_0 = inputValue;
     }
-    return new Promise((resolve, reject) => {
-      const reader = new FileReader;
-      reader.onloadend = () => {
-        const result = reader.result;
-        if (result.startsWith("data:;base64,")) {
-          resolve(`data:${mimeType};base64,${result.substring(13)}`);
-        } else {
-          resolve(result);
-        }
-      };
-      reader.onerror = reject;
-      reader.readAsDataURL(blob);
-    });
+    return output;
   }
 }
-TaskRegistry9.registerTask(FileLoaderTask);
-var fileLoader = (input2, config) => {
-  return new FileLoaderTask(input2, config).run();
+var split = (input2, config = {}) => {
+  const task = new SplitTask({}, config);
+  return task.run(input2);
 };
-Workflow9.prototype.fileLoader = CreateWorkflow9(FileLoaderTask);
+Workflow11.prototype.split = CreateWorkflow11(SplitTask);
+
+// src/common.ts
+import { TaskRegistry } from "@workglow/task-graph";
+var registerCommonTasks = () => {
+  const tasks = [
+    ArrayTask,
+    DebugLogTask,
+    DelayTask,
+    FetchUrlTask,
+    InputTask,
+    JavaScriptTask,
+    JsonTask,
+    LambdaTask,
+    MergeTask,
+    OutputTask,
+    SplitTask
+  ];
+  tasks.map(TaskRegistry.registerTask);
+  return tasks;
+};
+
+// src/browser.ts
+[FileLoaderTask].map(TaskRegistry2.registerTask);
 export {
   split,
+  registerCommonTasks,
   process,
   merge,
   lambda,
@@ -5531,16 +5748,20 @@ export {
   fetchUrl,
   delay,
   debugLog,
+  TypeReplicateArray,
   SplitTask,
+  OutputTask,
   MergeTask,
   LambdaTask,
   JsonTask,
   JavaScriptTask,
+  InputTask,
   FileLoaderTask,
   FetchUrlTask,
   FetchUrlJob,
   DelayTask,
-  DebugLogTask
+  DebugLogTask,
+  ArrayTask
 };
 
-//# debugId=0A217C65AC31B63164756E2164756E21
+//# debugId=B1BD272CB310F36564756E2164756E21