@happyvertical/utils 0.80.0 → 0.80.1

package/dist/index.js

@@ -1,394 +1,452 @@
+import { A as ApiError, B as enableLogging, C as prettyDate, D as urlFilename, E as snakeCase, F as NetworkError, G as extractAllCodeBlocks, H as setLogger, I as ParsingError, J as extractJSON, K as extractCodeBlock, L as TimeoutError, M as DatabaseError, N as ErrorCode, O as urlPath, P as FileError, Q as toScreamingSnakeCase, R as ValidationError, S as pluralizeWord, T as sleep, U as isSafeCode, V as getLogger, W as validateCode, X as loadEnvConfig, Y as convertType, Z as toCamelCase, _ as logTicker, a as domainToCamel, b as parseAmazonDateString, c as isArray, d as isPlural, f as isSingular, g as keysToSnake, h as keysToCamel, i as dateInString, j as BaseError, k as waitFor, l as isCuid, m as isValidDate, n as camelCase, o as formatDate, p as isUrl, q as extractFunctionDefinition, r as createId, s as getTempDirectory, t as addInterval, u as isPlainObject, v as makeId, w as singularize, x as parseDate, y as makeSlug, z as disableLogging } from "./chunks/universal-DOIuUel_.js";
 import { basename } from "node:path";
 import { parseArgs } from "node:util";
-import { A, B, D, E, F, N, P, T, V, a, c, b, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, C, G, H, I, J, K, L, M, O, Q, R, S, U, W, X, Y } from "./chunks/universal-BeseWxvS.js";
 import * as vm from "node:vm";
 import { createHash } from "node:crypto";
-import { isCuid } from "@paralleldrive/cuid2";
+//#region src/cli/parse-args.ts
+/**
+* CLI Argument Parsing Utility
+*
+* Provides robust parsing for multi-word commands, options, and arguments.
+* Supports Node.js util.parseArgs for option parsing with fallback.
+*/
+/**
+* Parse command line arguments with support for multi-word commands
+*
+* Handles:
+* - Multi-word commands (up to 3 words: "gnode create", "foo bar baz")
+* - Command aliases
+* - Positional arguments
+* - Options using Node.js util.parseArgs
+* - Global flags (--help, --version)
+* - Automatic removal of node/script paths
+*
+* @param argv - Process argv or custom argument array
+* @param commands - Array of command definitions to match against
+* @param builtInCommands - Optional map of additional built-in commands
+* @returns Parsed arguments with command, args, and options
+*
+* @example
+* ```typescript
+* const parsed = parseCliArgs(
+*   ['node', 'cli.js', 'gnode', 'create', 'my-site', '--template=town'],
+*   commands
+* );
+* // { command: 'gnode create', args: ['my-site'], options: { template: 'town' } }
+* ```
+*/
 function parseCliArgs(argv, commands, builtInCommands = {}) {
-  let args = argv;
-  if (args.length > 0 && basename(args[0]) === "node") {
-    args = args.slice(1);
-  }
-  if (args.length > 0 && args[0].endsWith(".js")) {
-    args = args.slice(1);
-  }
-  if (args.length === 0) {
-    return { args: [], options: {} };
-  }
-  if (args.includes("--help")) {
-    return { command: "help", args: [], options: {} };
-  }
-  if (args.includes("--version")) {
-    return { command: "version", args: [], options: {} };
-  }
-  let matchedCommand;
-  let commandName;
-  let commandWordCount = 0;
-  for (let i2 = Math.min(3, args.length); i2 > 0; i2--) {
-    const possibleCommand = args.slice(0, i2).join(" ");
-    const found = builtInCommands[possibleCommand] || commands.find(
-      (cmd) => cmd.name === possibleCommand || cmd.aliases?.includes(possibleCommand)
-    );
-    if (found) {
-      matchedCommand = found;
-      commandName = possibleCommand;
-      commandWordCount = i2;
-      break;
-    }
-  }
-  if (!commandName && args.length > 0) {
-    commandName = args[0];
-    commandWordCount = 1;
-    matchedCommand = commands.find(
-      (cmd) => cmd.name === commandName || cmd.aliases?.includes(commandName)
-    );
-  }
-  if (!matchedCommand) {
-    if (args.includes("-h")) {
-      return { command: "help", args: [], options: {} };
-    }
-    if (args.includes("-v")) {
-      return { command: "version", args: [], options: {} };
-    }
-    return {
-      command: commandName,
-      args: args.slice(1).filter((arg) => !arg.startsWith("-")),
-      options: {}
-    };
-  }
-  const parseConfig = {
-    args: args.slice(commandWordCount),
-    options: {},
-    strict: false,
-    // Allow unknown options
-    allowPositionals: true
-    // Required for mixing positional args and options
-  };
-  const numberOptions = /* @__PURE__ */ new Set();
-  if (matchedCommand.options) {
-    for (const [name, option] of Object.entries(matchedCommand.options)) {
-      const nodeType = option.type === "boolean" ? "boolean" : "string";
-      if (option.type === "number") {
-        numberOptions.add(name);
-      }
-      parseConfig.options[name] = {
-        type: nodeType
-      };
-      if (option.default !== void 0) {
-        parseConfig.options[name].default = option.type === "number" ? String(option.default) : option.default;
-      }
-      if (option.short) {
-        parseConfig.options[name].short = option.short;
-      }
-    }
-  }
-  try {
-    const parsed = parseArgs(parseConfig);
-    const options = parsed.values || {};
-    for (const name of numberOptions) {
-      if (name in options && options[name] !== void 0) {
-        const rawValue = options[name];
-        if (rawValue === "") {
-          throw new Error(`Invalid number for --${name}: "${rawValue}"`);
-        }
-        const value = Number(rawValue);
-        if (Number.isNaN(value)) {
-          throw new Error(`Invalid number for --${name}: "${rawValue}"`);
-        }
-        options[name] = value;
-      }
-    }
-    return {
-      command: commandName,
-      args: parsed.positionals || [],
-      options
-    };
-  } catch (error) {
-    if (error instanceof Error && error.message.startsWith("Invalid number")) {
-      throw error;
-    }
-    return {
-      command: commandName,
-      args: args.slice(commandWordCount).filter((arg) => !arg.startsWith("-")),
-      options: {}
-    };
-  }
+	let args = argv;
+	if (args.length > 0 && basename(args[0]) === "node") args = args.slice(1);
+	if (args.length > 0 && args[0].endsWith(".js")) args = args.slice(1);
+	if (args.length === 0) return {
+		args: [],
+		options: {}
+	};
+	if (args.includes("--help")) return {
+		command: "help",
+		args: [],
+		options: {}
+	};
+	if (args.includes("--version")) return {
+		command: "version",
+		args: [],
+		options: {}
+	};
+	let matchedCommand;
+	let commandName;
+	let commandWordCount = 0;
+	for (let i = Math.min(3, args.length); i > 0; i--) {
+		const possibleCommand = args.slice(0, i).join(" ");
+		const found = builtInCommands[possibleCommand] || commands.find((cmd) => cmd.name === possibleCommand || cmd.aliases?.includes(possibleCommand));
+		if (found) {
+			matchedCommand = found;
+			commandName = possibleCommand;
+			commandWordCount = i;
+			break;
+		}
+	}
+	if (!commandName && args.length > 0) {
+		commandName = args[0];
+		commandWordCount = 1;
+		matchedCommand = commands.find((cmd) => cmd.name === commandName || cmd.aliases?.includes(commandName));
+	}
+	if (!matchedCommand) {
+		if (args.includes("-h")) return {
+			command: "help",
+			args: [],
+			options: {}
+		};
+		if (args.includes("-v")) return {
+			command: "version",
+			args: [],
+			options: {}
+		};
+		return {
+			command: commandName,
+			args: args.slice(1).filter((arg) => !arg.startsWith("-")),
+			options: {}
+		};
+	}
+	const parseConfig = {
+		args: args.slice(commandWordCount),
+		options: {},
+		strict: false,
+		allowPositionals: true
+	};
+	const numberOptions = /* @__PURE__ */ new Set();
+	if (matchedCommand.options) for (const [name, option] of Object.entries(matchedCommand.options)) {
+		const nodeType = option.type === "boolean" ? "boolean" : "string";
+		if (option.type === "number") numberOptions.add(name);
+		parseConfig.options[name] = { type: nodeType };
+		if (option.default !== void 0) parseConfig.options[name].default = option.type === "number" ? String(option.default) : option.default;
+		if (option.short) parseConfig.options[name].short = option.short;
+	}
+	try {
+		const parsed = parseArgs(parseConfig);
+		const options = parsed.values || {};
+		for (const name of numberOptions) if (name in options && options[name] !== void 0) {
+			const rawValue = options[name];
+			if (rawValue === "") throw new Error(`Invalid number for --${name}: "${rawValue}"`);
+			const value = Number(rawValue);
+			if (Number.isNaN(value)) throw new Error(`Invalid number for --${name}: "${rawValue}"`);
+			options[name] = value;
+		}
+		return {
+			command: commandName,
+			args: parsed.positionals || [],
+			options
+		};
+	} catch (error) {
+		if (error instanceof Error && error.message.startsWith("Invalid number")) throw error;
+		return {
+			command: commandName,
+			args: args.slice(commandWordCount).filter((arg) => !arg.startsWith("-")),
+			options: {}
+		};
+	}
 }
+//#endregion
+//#region src/cli/parse-flags.ts
 function parseFlagArgs(args) {
-  const flags = {};
-  const positionals = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (arg === "--") {
-      positionals.push(...args.slice(index + 1));
-      break;
-    }
-    if (!arg.startsWith("--")) {
-      positionals.push(arg);
-      continue;
-    }
-    const [rawKey, inlineValue] = arg.slice(2).split(/=(.*)/su, 2);
-    if (rawKey === "") {
-      throw new Error(
-        `Invalid flag token "${arg}": flag name is empty. Use --key=value or --key value.`
-      );
-    }
-    const key = rawKey.replace(
-      /-([a-z])/gu,
-      (_match, letter) => letter.toUpperCase()
-    );
-    if (inlineValue !== void 0) {
-      flags[key] = inlineValue;
-      continue;
-    }
-    const next = args[index + 1];
-    if (next !== void 0 && !next.startsWith("--")) {
-      flags[key] = next;
-      index += 1;
-    } else {
-      flags[key] = true;
-    }
-  }
-  return { flags, positionals };
+	const flags = {};
+	const positionals = [];
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--") {
+			positionals.push(...args.slice(index + 1));
+			break;
+		}
+		if (!arg.startsWith("--")) {
+			positionals.push(arg);
+			continue;
+		}
+		const [rawKey, inlineValue] = arg.slice(2).split(/=(.*)/su, 2);
+		if (rawKey === "") throw new Error(`Invalid flag token "${arg}": flag name is empty. Use --key=value or --key value.`);
+		const key = rawKey.replace(/-([a-z])/gu, (_match, letter) => letter.toUpperCase());
+		if (inlineValue !== void 0) {
+			flags[key] = inlineValue;
+			continue;
+		}
+		const next = args[index + 1];
+		if (next !== void 0 && !next.startsWith("--")) {
+			flags[key] = next;
+			index += 1;
+		} else flags[key] = true;
+	}
+	return {
+		flags,
+		positionals
+	};
 }
-const DEFAULT_BUILTINS = [
-  "Array",
-  "Object",
-  "JSON",
-  "Math",
-  "Date",
-  "String",
-  "Number",
-  "Boolean",
-  "RegExp",
-  "Set",
-  "Map",
-  "WeakSet",
-  "WeakMap",
-  "Symbol",
-  "Promise"
+//#endregion
+//#region src/shared/code/sandbox.ts
+/**
+* Sandbox creation and safe code execution utilities
+*
+* Provides secure execution of generated code in isolated VM contexts with
+* controlled globals, timeouts, and resource constraints.
+*/
+/**
+* Default safe built-in objects available in the sandbox
+*/
+var DEFAULT_BUILTINS = [
+	"Array",
+	"Object",
+	"JSON",
+	"Math",
+	"Date",
+	"String",
+	"Number",
+	"Boolean",
+	"RegExp",
+	"Set",
+	"Map",
+	"WeakSet",
+	"WeakMap",
+	"Symbol",
+	"Promise"
 ];
+/**
+* Creates a secure sandbox execution context with controlled globals
+*
+* @param options - Configuration for the sandbox
+* @returns A VM context that can be used with executeCode()
+*
+* @example
+* ```typescript
+* const sandbox = createSandbox({
+*   globals: {
+*     cheerio: require('cheerio'),
+*     data: { foo: 'bar' }
+*   },
+*   timeout: 5000,
+*   allowedBuiltins: ['Array', 'Object', 'JSON']
+* });
+*
+* const result = executeCode('data.foo', sandbox);
+* // Returns: "bar"
+* ```
+*/
 function createSandbox(options = {}) {
-  const {
-    globals = {},
-    allowedBuiltins = DEFAULT_BUILTINS,
-    allowConsole = false
-  } = options;
-  const sandbox = /* @__PURE__ */ Object.create(null);
-  for (const builtin of allowedBuiltins) {
-    if (builtin in globalThis) {
-      sandbox[builtin] = globalThis[builtin];
-    }
-  }
-  if (allowConsole) {
-    sandbox.console = console;
-  }
-  Object.assign(sandbox, globals);
-  return vm.createContext(sandbox);
+	const { globals = {}, allowedBuiltins = DEFAULT_BUILTINS, allowConsole = false } = options;
+	const sandbox = Object.create(null);
+	for (const builtin of allowedBuiltins) if (builtin in globalThis) sandbox[builtin] = globalThis[builtin];
+	if (allowConsole) sandbox.console = console;
+	Object.assign(sandbox, globals);
+	return vm.createContext(sandbox);
 }
+/**
+* Executes code in a sandbox with timeout and error handling
+*
+* @param code - The JavaScript code to execute
+* @param sandbox - The VM context created by createSandbox()
+* @param options - Execution options
+* @returns The result of the code execution
+* @throws {Error} If code execution fails or times out
+*
+* @example
+* ```typescript
+* const sandbox = createSandbox({
+*   globals: { x: 10, y: 20 }
+* });
+*
+* const result = executeCode('x + y', sandbox);
+* // Returns: 30
+*
+* // With a function
+* const funcResult = executeCode(`
+*   function add(a, b) {
+*     return a + b;
+*   }
+*   add(x, y);
+* `, sandbox);
+* // Returns: 30
+* ```
+*/
 function executeCode(code, sandbox, options = {}) {
-  const {
-    timeout = 5e3,
-    filename = "generated-code.js",
-    captureResult = true
-  } = options;
-  try {
-    let wrappedCode;
-    if (captureResult) {
-      const hasMultipleStatements = code.includes(";") || code.includes("\n") && code.trim().split("\n").length > 1;
-      const hasFunctionDef = /function\s+\w+|const\s+\w+\s*=\s*function|const\s+\w+\s*=\s*\(/i.test(
-        code
-      );
-      if (hasMultipleStatements || hasFunctionDef) {
-        wrappedCode = code;
-      } else {
-        wrappedCode = `(function() { return (${code}); })();`;
-      }
-    } else {
-      wrappedCode = code;
-    }
-    const result = vm.runInContext(wrappedCode, sandbox, {
-      timeout,
-      filename,
-      displayErrors: true
-    });
-    return result;
-  } catch (error) {
-    if (error instanceof Error) {
-      const message = `Code execution failed: ${error.message}`;
-      const enhancedError = new Error(message);
-      enhancedError.stack = error.stack;
-      throw enhancedError;
-    }
-    throw error;
-  }
+	const { timeout = 5e3, filename = "generated-code.js", captureResult = true } = options;
+	try {
+		let wrappedCode;
+		if (captureResult) {
+			const hasMultipleStatements = code.includes(";") || code.includes("\n") && code.trim().split("\n").length > 1;
+			const hasFunctionDef = /function\s+\w+|const\s+\w+\s*=\s*function|const\s+\w+\s*=\s*\(/i.test(code);
+			if (hasMultipleStatements || hasFunctionDef) wrappedCode = code;
+			else wrappedCode = `(function() { return (${code}); })();`;
+		} else wrappedCode = code;
+		return vm.runInContext(wrappedCode, sandbox, {
+			timeout,
+			filename,
+			displayErrors: true
+		});
+	} catch (error) {
+		if (error instanceof Error) {
+			const message = `Code execution failed: ${error.message}`;
+			const enhancedError = new Error(message);
+			enhancedError.stack = error.stack;
+			throw enhancedError;
+		}
+		throw error;
+	}
 }
+/**
+* Executes async code in a sandbox with timeout and error handling
+*
+* @param code - The JavaScript code to execute (can contain async/await)
+* @param sandbox - The VM context created by createSandbox()
+* @param options - Execution options
+* @returns Promise resolving to the result of the code execution
+* @throws {Error} If code execution fails or times out
+*
+* @example
+* ```typescript
+* const sandbox = createSandbox({
+*   globals: {
+*     fetch: require('node-fetch')
+*   }
+* });
+*
+* const result = await executeCodeAsync(`
+*   const response = await fetch('https://api.example.com/data');
+*   const data = await response.json();
+*   data;
+* `, sandbox);
+* ```
+*/
 async function executeCodeAsync(code, sandbox, options = {}) {
-  const {
-    timeout = 5e3,
-    filename = "generated-code.js",
-    captureResult = true
-  } = options;
-  try {
-    let wrappedCode;
-    if (captureResult) {
-      const trimmedCode = code.trim();
-      const lines = trimmedCode.split("\n");
-      if (lines.length > 1 || trimmedCode.includes(";")) {
-        const statements = trimmedCode.split("\n").filter((line) => line.trim());
-        const lastLine = statements[statements.length - 1];
-        const otherLines = statements.slice(0, -1);
-        if (lastLine.trim().startsWith("return ")) {
-          wrappedCode = `(async function() {
+	const { timeout = 5e3, filename = "generated-code.js", captureResult = true } = options;
+	try {
+		let wrappedCode;
+		if (captureResult) {
+			const trimmedCode = code.trim();
+			if (trimmedCode.split("\n").length > 1 || trimmedCode.includes(";")) {
+				const statements = trimmedCode.split("\n").filter((line) => line.trim());
+				const lastLine = statements[statements.length - 1];
+				const otherLines = statements.slice(0, -1);
+				if (lastLine.trim().startsWith("return ")) wrappedCode = `(async function() {
             ${trimmedCode}
           })();`;
-        } else {
-          const lastExpression = lastLine.trim().replace(/;$/, "");
-          wrappedCode = `(async function() {
+				else {
+					const lastExpression = lastLine.trim().replace(/;$/, "");
+					wrappedCode = `(async function() {
             ${otherLines.join("\n")}
             return ${lastExpression};
           })();`;
-        }
-      } else {
-        wrappedCode = `(async function() {
+				}
+			} else wrappedCode = `(async function() {
           return (${trimmedCode});
         })();`;
-      }
-    } else {
-      wrappedCode = `(async function() {
+		} else wrappedCode = `(async function() {
         ${code}
       })();`;
-    }
-    const result = await vm.runInContext(wrappedCode, sandbox, {
-      timeout,
-      filename,
-      displayErrors: true
-    });
-    return result;
-  } catch (error) {
-    if (error instanceof Error) {
-      const message = `Async code execution failed: ${error.message}`;
-      const enhancedError = new Error(message);
-      enhancedError.stack = error.stack;
-      throw enhancedError;
-    }
-    throw error;
-  }
+		return await vm.runInContext(wrappedCode, sandbox, {
+			timeout,
+			filename,
+			displayErrors: true
+		});
+	} catch (error) {
+		if (error instanceof Error) {
+			const message = `Async code execution failed: ${error.message}`;
+			const enhancedError = new Error(message);
+			enhancedError.stack = error.stack;
+			throw enhancedError;
+		}
+		throw error;
+	}
 }
+/**
+* Convenience function to create a sandbox and execute code in one step
+*
+* @param code - The JavaScript code to execute
+* @param options - Combined sandbox and execution options
+* @returns The result of the code execution
+*
+* @example
+* ```typescript
+* const result = executeInSandbox('Math.sqrt(16)', {
+*   globals: { x: 10 },
+*   timeout: 1000
+* });
+* // Returns: 4
+* ```
+*/
 function executeInSandbox(code, options = {}) {
-  const sandbox = createSandbox(options);
-  return executeCode(code, sandbox, options);
+	return executeCode(code, createSandbox(options), options);
 }
+/**
+* Convenience function to create a sandbox and execute async code in one step
+*
+* @param code - The JavaScript code to execute (can contain async/await)
+* @param options - Combined sandbox and execution options
+* @returns Promise resolving to the result of the code execution
+*
+* @example
+* ```typescript
+* const result = await executeInSandboxAsync(`
+*   const data = await Promise.resolve({ value: 42 });
+*   data.value;
+* `, {
+*   timeout: 2000
+* });
+* // Returns: 42
+* ```
+*/
 async function executeInSandboxAsync(code, options = {}) {
-  const sandbox = createSandbox(options);
-  return executeCodeAsync(code, sandbox, options);
+	return executeCodeAsync(code, createSandbox(options), options);
 }
+//#endregion
+//#region src/web.ts
+/**
+* Web and URL utility functions
+*
+* General-purpose utilities for working with URLs and web content.
+* Used by scrapers, note systems, and content processors.
+*/
+/**
+* Normalize URL for consistent key storage
+* Removes tracking params, sorts query string, lowercases, etc.
+*
+* @param url - The URL to normalize
+* @returns Normalized URL string
+*/
 function normalizeUrl(url) {
-  const parsed = new URL(url);
-  parsed.protocol = parsed.protocol.toLowerCase();
-  parsed.hostname = parsed.hostname.toLowerCase();
-  parsed.hostname = parsed.hostname.replace(/^www\./, "");
-  if (parsed.protocol === "http:" && parsed.port === "80" || parsed.protocol === "https:" && parsed.port === "443") {
-    parsed.port = "";
-  }
-  parsed.hash = "";
-  const params = new URLSearchParams(parsed.search);
-  const filtered = new URLSearchParams();
-  const trackingParams = [
-    "utm_source",
-    "utm_medium",
-    "utm_campaign",
-    "utm_content",
-    "utm_term",
-    "fbclid",
-    "gclid",
-    "msclkid",
-    "_ga",
-    "mc_cid",
-    "mc_eid"
-  ];
-  Array.from(params.keys()).sort().forEach((key) => {
-    if (!trackingParams.includes(key)) {
-      filtered.set(key, params.get(key));
-    }
-  });
-  parsed.search = filtered.toString();
-  return parsed.toString();
+	const parsed = new URL(url);
+	parsed.protocol = parsed.protocol.toLowerCase();
+	parsed.hostname = parsed.hostname.toLowerCase();
+	parsed.hostname = parsed.hostname.replace(/^www\./, "");
+	if (parsed.protocol === "http:" && parsed.port === "80" || parsed.protocol === "https:" && parsed.port === "443") parsed.port = "";
+	parsed.hash = "";
+	const params = new URLSearchParams(parsed.search);
+	const filtered = new URLSearchParams();
+	const trackingParams = [
+		"utm_source",
+		"utm_medium",
+		"utm_campaign",
+		"utm_content",
+		"utm_term",
+		"fbclid",
+		"gclid",
+		"msclkid",
+		"_ga",
+		"mc_cid",
+		"mc_eid"
+	];
+	Array.from(params.keys()).sort().forEach((key) => {
+		if (!trackingParams.includes(key)) filtered.set(key, params.get(key));
+	});
+	parsed.search = filtered.toString();
+	return parsed.toString();
 }
+/**
+* Generate hierarchical scope from URL for organized note storage
+*
+* @param url - The URL to generate scope from
+* @param baseScope - Base scope prefix (default: 'discovery/parser')
+* @returns Hierarchical scope string
+*
+* @example
+* generateScopeFromUrl('https://cityofboston.gov/meetings/minutes')
+* // Returns: 'discovery/parser/cityofboston.gov/meetings'
+*/
 function generateScopeFromUrl(url, baseScope = "discovery/parser") {
-  const parsed = new URL(normalizeUrl(url));
-  const domain = parsed.hostname;
-  const pathParts = parsed.pathname.split("/").filter((p2) => p2);
-  const pageType = pathParts[0] || "index";
-  return `${baseScope}/${domain}/${pageType}`;
+	const parsed = new URL(normalizeUrl(url));
+	return `${baseScope}/${parsed.hostname}/${parsed.pathname.split("/").filter((p) => p)[0] || "index"}`;
 }
+/**
+* Hash page content for change detection
+* Uses SHA-256 to create a unique fingerprint of the HTML
+*
+* @param html - Page HTML content
+* @returns SHA-256 hash as hex string
+*/
 function hashPageContent(html) {
-  return createHash("sha256").update(html).digest("hex");
+	return createHash("sha256").update(html).digest("hex");
 }
-const PACKAGE_VERSION_INITIALIZED = true;
-export {
-  A as ApiError,
-  B as BaseError,
-  D as DatabaseError,
-  E as ErrorCode,
-  F as FileError,
-  N as NetworkError,
-  PACKAGE_VERSION_INITIALIZED,
-  P as ParsingError,
-  T as TimeoutError,
-  V as ValidationError,
-  a as addInterval,
-  c as camelCase,
-  b as convertType,
-  d as createId,
-  createSandbox,
-  e as dateInString,
-  f as disableLogging,
-  g as domainToCamel,
-  h as enableLogging,
-  executeCode,
-  executeCodeAsync,
-  executeInSandbox,
-  executeInSandboxAsync,
-  i as extractAllCodeBlocks,
-  j as extractCodeBlock,
-  k as extractFunctionDefinition,
-  l as extractJSON,
-  m as formatDate,
-  generateScopeFromUrl,
-  n as getLogger,
-  o as getTempDirectory,
-  hashPageContent,
-  p as isArray,
-  isCuid,
-  q as isPlainObject,
-  r as isPlural,
-  s as isSafeCode,
-  t as isSingular,
-  u as isUrl,
-  v as isValidDate,
-  w as keysToCamel,
-  x as keysToSnake,
-  y as loadEnvConfig,
-  z as logTicker,
-  C as makeId,
-  G as makeSlug,
-  normalizeUrl,
-  H as parseAmazonDateString,
-  parseCliArgs,
-  I as parseDate,
-  parseFlagArgs,
-  J as pluralizeWord,
-  K as prettyDate,
-  L as setLogger,
-  M as singularize,
-  O as sleep,
-  Q as snakeCase,
-  R as toCamelCase,
-  S as toScreamingSnakeCase,
-  U as urlFilename,
-  W as urlPath,
-  X as validateCode,
-  Y as waitFor
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+//#region src/index.ts
+/** @internal */
+var PACKAGE_VERSION_INITIALIZED = true;
+//#endregion
+export { ApiError, BaseError, DatabaseError, ErrorCode, FileError, NetworkError, PACKAGE_VERSION_INITIALIZED, ParsingError, TimeoutError, ValidationError, addInterval, camelCase, convertType, createId, createSandbox, dateInString, disableLogging, domainToCamel, enableLogging, executeCode, executeCodeAsync, executeInSandbox, executeInSandboxAsync, extractAllCodeBlocks, extractCodeBlock, extractFunctionDefinition, extractJSON, formatDate, generateScopeFromUrl, getLogger, getTempDirectory, hashPageContent, isArray, isCuid, isPlainObject, isPlural, isSafeCode, isSingular, isUrl, isValidDate, keysToCamel, keysToSnake, loadEnvConfig, logTicker, makeId, makeSlug, normalizeUrl, parseAmazonDateString, parseCliArgs, parseDate, parseFlagArgs, pluralizeWord, prettyDate, setLogger, singularize, sleep, snakeCase, toCamelCase, toScreamingSnakeCase, urlFilename, urlPath, validateCode, waitFor };
+
+//# sourceMappingURL=index.js.map